xref: /openbmc/linux/kernel/power/user.c (revision 9ac8d3fb) 
1 /*
2  * linux/kernel/power/user.c
3  *
4  * This file provides the user space interface for software suspend/resume.
5  *
6  * Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
7  *
8  * This file is released under the GPLv2.
9  *
10  */
11 
12 #include <linux/suspend.h>
13 #include <linux/syscalls.h>
14 #include <linux/reboot.h>
15 #include <linux/string.h>
16 #include <linux/device.h>
17 #include <linux/miscdevice.h>
18 #include <linux/mm.h>
19 #include <linux/swap.h>
20 #include <linux/swapops.h>
21 #include <linux/pm.h>
22 #include <linux/fs.h>
23 #include <linux/console.h>
24 #include <linux/cpu.h>
25 #include <linux/freezer.h>
26 #include <linux/smp_lock.h>
27 
28 #include <asm/uaccess.h>
29 
30 #include "power.h"
31 
32 /*
33  * NOTE: The SNAPSHOT_SET_SWAP_FILE and SNAPSHOT_PMOPS ioctls are obsolete and
34  * will be removed in the future.  They are only preserved here for
35  * compatibility with existing userland utilities.
36  */
37 #define SNAPSHOT_SET_SWAP_FILE	_IOW(SNAPSHOT_IOC_MAGIC, 10, unsigned int)
38 #define SNAPSHOT_PMOPS		_IOW(SNAPSHOT_IOC_MAGIC, 12, unsigned int)
39 
40 #define PMOPS_PREPARE	1
41 #define PMOPS_ENTER	2
42 #define PMOPS_FINISH	3
43 
44 /*
45  * NOTE: The following ioctl definitions are wrong and have been replaced with
46  * correct ones.  They are only preserved here for compatibility with existing
47  * userland utilities and will be removed in the future.
48  */
49 #define SNAPSHOT_ATOMIC_SNAPSHOT	_IOW(SNAPSHOT_IOC_MAGIC, 3, void *)
50 #define SNAPSHOT_SET_IMAGE_SIZE		_IOW(SNAPSHOT_IOC_MAGIC, 6, unsigned long)
51 #define SNAPSHOT_AVAIL_SWAP		_IOR(SNAPSHOT_IOC_MAGIC, 7, void *)
52 #define SNAPSHOT_GET_SWAP_PAGE		_IOR(SNAPSHOT_IOC_MAGIC, 8, void *)
53 
54 
55 #define SNAPSHOT_MINOR	231
56 
57 static struct snapshot_data {
58 	struct snapshot_handle handle;
59 	int swap;
60 	int mode;
61 	char frozen;
62 	char ready;
63 	char platform_support;
64 } snapshot_state;
65 
66 atomic_t snapshot_device_available = ATOMIC_INIT(1);
67 
68 static int snapshot_open(struct inode *inode, struct file *filp)
69 {
70 	struct snapshot_data *data;
71 	int error;
72 
73 	mutex_lock(&pm_mutex);
74 
75 	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
76 		error = -EBUSY;
77 		goto Unlock;
78 	}
79 
80 	if ((filp->f_flags & O_ACCMODE) == O_RDWR) {
81 		atomic_inc(&snapshot_device_available);
82 		error = -ENOSYS;
83 		goto Unlock;
84 	}
85 	if(create_basic_memory_bitmaps()) {
86 		atomic_inc(&snapshot_device_available);
87 		error = -ENOMEM;
88 		goto Unlock;
89 	}
90 	nonseekable_open(inode, filp);
91 	data = &snapshot_state;
92 	filp->private_data = data;
93 	memset(&data->handle, 0, sizeof(struct snapshot_handle));
94 	if ((filp->f_flags & O_ACCMODE) == O_RDONLY) {
95 		data->swap = swsusp_resume_device ?
96 			swap_type_of(swsusp_resume_device, 0, NULL) : -1;
97 		data->mode = O_RDONLY;
98 		error = pm_notifier_call_chain(PM_RESTORE_PREPARE);
99 		if (error)
100 			pm_notifier_call_chain(PM_POST_RESTORE);
101 	} else {
102 		data->swap = -1;
103 		data->mode = O_WRONLY;
104 		error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
105 		if (error)
106 			pm_notifier_call_chain(PM_POST_HIBERNATION);
107 	}
108 	if (error)
109 		atomic_inc(&snapshot_device_available);
110 	data->frozen = 0;
111 	data->ready = 0;
112 	data->platform_support = 0;
113 
114  Unlock:
115 	mutex_unlock(&pm_mutex);
116 
117 	return error;
118 }
119 
120 static int snapshot_release(struct inode *inode, struct file *filp)
121 {
122 	struct snapshot_data *data;
123 
124 	mutex_lock(&pm_mutex);
125 
126 	swsusp_free();
127 	free_basic_memory_bitmaps();
128 	data = filp->private_data;
129 	free_all_swap_pages(data->swap);
130 	if (data->frozen)
131 		thaw_processes();
132 	pm_notifier_call_chain(data->mode == O_WRONLY ?
133 			PM_POST_HIBERNATION : PM_POST_RESTORE);
134 	atomic_inc(&snapshot_device_available);
135 
136 	mutex_unlock(&pm_mutex);
137 
138 	return 0;
139 }
140 
141 static ssize_t snapshot_read(struct file *filp, char __user *buf,
142                              size_t count, loff_t *offp)
143 {
144 	struct snapshot_data *data;
145 	ssize_t res;
146 
147 	mutex_lock(&pm_mutex);
148 
149 	data = filp->private_data;
150 	if (!data->ready) {
151 		res = -ENODATA;
152 		goto Unlock;
153 	}
154 	res = snapshot_read_next(&data->handle, count);
155 	if (res > 0) {
156 		if (copy_to_user(buf, data_of(data->handle), res))
157 			res = -EFAULT;
158 		else
159 			*offp = data->handle.offset;
160 	}
161 
162  Unlock:
163 	mutex_unlock(&pm_mutex);
164 
165 	return res;
166 }
167 
168 static ssize_t snapshot_write(struct file *filp, const char __user *buf,
169                               size_t count, loff_t *offp)
170 {
171 	struct snapshot_data *data;
172 	ssize_t res;
173 
174 	mutex_lock(&pm_mutex);
175 
176 	data = filp->private_data;
177 	res = snapshot_write_next(&data->handle, count);
178 	if (res > 0) {
179 		if (copy_from_user(data_of(data->handle), buf, res))
180 			res = -EFAULT;
181 		else
182 			*offp = data->handle.offset;
183 	}
184 
185 	mutex_unlock(&pm_mutex);
186 
187 	return res;
188 }
189 
190 static long snapshot_ioctl(struct file *filp, unsigned int cmd,
191 							unsigned long arg)
192 {
193 	int error = 0;
194 	struct snapshot_data *data;
195 	loff_t size;
196 	sector_t offset;
197 
198 	if (_IOC_TYPE(cmd) != SNAPSHOT_IOC_MAGIC)
199 		return -ENOTTY;
200 	if (_IOC_NR(cmd) > SNAPSHOT_IOC_MAXNR)
201 		return -ENOTTY;
202 	if (!capable(CAP_SYS_ADMIN))
203 		return -EPERM;
204 
205 	if (!mutex_trylock(&pm_mutex))
206 		return -EBUSY;
207 
208 	data = filp->private_data;
209 
210 	switch (cmd) {
211 
212 	case SNAPSHOT_FREEZE:
213 		if (data->frozen)
214 			break;
215 
216 		printk("Syncing filesystems ... ");
217 		sys_sync();
218 		printk("done.\n");
219 
220 		error = usermodehelper_disable();
221 		if (error)
222 			break;
223 
224 		error = freeze_processes();
225 		if (error) {
226 			thaw_processes();
227 			usermodehelper_enable();
228 		}
229 		if (!error)
230 			data->frozen = 1;
231 		break;
232 
233 	case SNAPSHOT_UNFREEZE:
234 		if (!data->frozen || data->ready)
235 			break;
236 		thaw_processes();
237 		usermodehelper_enable();
238 		data->frozen = 0;
239 		break;
240 
241 	case SNAPSHOT_CREATE_IMAGE:
242 	case SNAPSHOT_ATOMIC_SNAPSHOT:
243 		if (data->mode != O_RDONLY || !data->frozen  || data->ready) {
244 			error = -EPERM;
245 			break;
246 		}
247 		error = hibernation_snapshot(data->platform_support);
248 		if (!error)
249 			error = put_user(in_suspend, (int __user *)arg);
250 		if (!error)
251 			data->ready = 1;
252 		break;
253 
254 	case SNAPSHOT_ATOMIC_RESTORE:
255 		snapshot_write_finalize(&data->handle);
256 		if (data->mode != O_WRONLY || !data->frozen ||
257 		    !snapshot_image_loaded(&data->handle)) {
258 			error = -EPERM;
259 			break;
260 		}
261 		error = hibernation_restore(data->platform_support);
262 		break;
263 
264 	case SNAPSHOT_FREE:
265 		swsusp_free();
266 		memset(&data->handle, 0, sizeof(struct snapshot_handle));
267 		data->ready = 0;
268 		break;
269 
270 	case SNAPSHOT_PREF_IMAGE_SIZE:
271 	case SNAPSHOT_SET_IMAGE_SIZE:
272 		image_size = arg;
273 		break;
274 
275 	case SNAPSHOT_GET_IMAGE_SIZE:
276 		if (!data->ready) {
277 			error = -ENODATA;
278 			break;
279 		}
280 		size = snapshot_get_image_size();
281 		size <<= PAGE_SHIFT;
282 		error = put_user(size, (loff_t __user *)arg);
283 		break;
284 
285 	case SNAPSHOT_AVAIL_SWAP_SIZE:
286 	case SNAPSHOT_AVAIL_SWAP:
287 		size = count_swap_pages(data->swap, 1);
288 		size <<= PAGE_SHIFT;
289 		error = put_user(size, (loff_t __user *)arg);
290 		break;
291 
292 	case SNAPSHOT_ALLOC_SWAP_PAGE:
293 	case SNAPSHOT_GET_SWAP_PAGE:
294 		if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
295 			error = -ENODEV;
296 			break;
297 		}
298 		offset = alloc_swapdev_block(data->swap);
299 		if (offset) {
300 			offset <<= PAGE_SHIFT;
301 			error = put_user(offset, (loff_t __user *)arg);
302 		} else {
303 			error = -ENOSPC;
304 		}
305 		break;
306 
307 	case SNAPSHOT_FREE_SWAP_PAGES:
308 		if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
309 			error = -ENODEV;
310 			break;
311 		}
312 		free_all_swap_pages(data->swap);
313 		break;
314 
315 	case SNAPSHOT_SET_SWAP_FILE: /* This ioctl is deprecated */
316 		if (!swsusp_swap_in_use()) {
317 			/*
318 			 * User space encodes device types as two-byte values,
319 			 * so we need to recode them
320 			 */
321 			if (old_decode_dev(arg)) {
322 				data->swap = swap_type_of(old_decode_dev(arg),
323 							0, NULL);
324 				if (data->swap < 0)
325 					error = -ENODEV;
326 			} else {
327 				data->swap = -1;
328 				error = -EINVAL;
329 			}
330 		} else {
331 			error = -EPERM;
332 		}
333 		break;
334 
335 	case SNAPSHOT_S2RAM:
336 		if (!data->frozen) {
337 			error = -EPERM;
338 			break;
339 		}
340 		/*
341 		 * Tasks are frozen and the notifiers have been called with
342 		 * PM_HIBERNATION_PREPARE
343 		 */
344 		error = suspend_devices_and_enter(PM_SUSPEND_MEM);
345 		break;
346 
347 	case SNAPSHOT_PLATFORM_SUPPORT:
348 		data->platform_support = !!arg;
349 		break;
350 
351 	case SNAPSHOT_POWER_OFF:
352 		if (data->platform_support)
353 			error = hibernation_platform_enter();
354 		break;
355 
356 	case SNAPSHOT_PMOPS: /* This ioctl is deprecated */
357 		error = -EINVAL;
358 
359 		switch (arg) {
360 
361 		case PMOPS_PREPARE:
362 			data->platform_support = 1;
363 			error = 0;
364 			break;
365 
366 		case PMOPS_ENTER:
367 			if (data->platform_support)
368 				error = hibernation_platform_enter();
369 			break;
370 
371 		case PMOPS_FINISH:
372 			if (data->platform_support)
373 				error = 0;
374 			break;
375 
376 		default:
377 			printk(KERN_ERR "SNAPSHOT_PMOPS: invalid argument %ld\n", arg);
378 
379 		}
380 		break;
381 
382 	case SNAPSHOT_SET_SWAP_AREA:
383 		if (swsusp_swap_in_use()) {
384 			error = -EPERM;
385 		} else {
386 			struct resume_swap_area swap_area;
387 			dev_t swdev;
388 
389 			error = copy_from_user(&swap_area, (void __user *)arg,
390 					sizeof(struct resume_swap_area));
391 			if (error) {
392 				error = -EFAULT;
393 				break;
394 			}
395 
396 			/*
397 			 * User space encodes device types as two-byte values,
398 			 * so we need to recode them
399 			 */
400 			swdev = old_decode_dev(swap_area.dev);
401 			if (swdev) {
402 				offset = swap_area.offset;
403 				data->swap = swap_type_of(swdev, offset, NULL);
404 				if (data->swap < 0)
405 					error = -ENODEV;
406 			} else {
407 				data->swap = -1;
408 				error = -EINVAL;
409 			}
410 		}
411 		break;
412 
413 	default:
414 		error = -ENOTTY;
415 
416 	}
417 
418 	mutex_unlock(&pm_mutex);
419 
420 	return error;
421 }
422 
423 static const struct file_operations snapshot_fops = {
424 	.open = snapshot_open,
425 	.release = snapshot_release,
426 	.read = snapshot_read,
427 	.write = snapshot_write,
428 	.llseek = no_llseek,
429 	.unlocked_ioctl = snapshot_ioctl,
430 };
431 
432 static struct miscdevice snapshot_device = {
433 	.minor = SNAPSHOT_MINOR,
434 	.name = "snapshot",
435 	.fops = &snapshot_fops,
436 };
437 
438 static int __init snapshot_device_init(void)
439 {
440 	return misc_register(&snapshot_device);
441 };
442 
443 device_initcall(snapshot_device_init);
444