Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound-2.6
[linux-2.6] / kernel / power / user.c
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                 printk("Syncing filesystems ... ");
216                 sys_sync();
217                 printk("done.\n");
218
219                 error = freeze_processes();
220                 if (error)
221                         thaw_processes();
222                 if (!error)
223                         data->frozen = 1;
224                 break;
225
226         case SNAPSHOT_UNFREEZE:
227                 if (!data->frozen || data->ready)
228                         break;
229                 thaw_processes();
230                 data->frozen = 0;
231                 break;
232
233         case SNAPSHOT_CREATE_IMAGE:
234         case SNAPSHOT_ATOMIC_SNAPSHOT:
235                 if (data->mode != O_RDONLY || !data->frozen  || data->ready) {
236                         error = -EPERM;
237                         break;
238                 }
239                 error = hibernation_snapshot(data->platform_support);
240                 if (!error)
241                         error = put_user(in_suspend, (int __user *)arg);
242                 if (!error)
243                         data->ready = 1;
244                 break;
245
246         case SNAPSHOT_ATOMIC_RESTORE:
247                 snapshot_write_finalize(&data->handle);
248                 if (data->mode != O_WRONLY || !data->frozen ||
249                     !snapshot_image_loaded(&data->handle)) {
250                         error = -EPERM;
251                         break;
252                 }
253                 error = hibernation_restore(data->platform_support);
254                 break;
255
256         case SNAPSHOT_FREE:
257                 swsusp_free();
258                 memset(&data->handle, 0, sizeof(struct snapshot_handle));
259                 data->ready = 0;
260                 break;
261
262         case SNAPSHOT_PREF_IMAGE_SIZE:
263         case SNAPSHOT_SET_IMAGE_SIZE:
264                 image_size = arg;
265                 break;
266
267         case SNAPSHOT_GET_IMAGE_SIZE:
268                 if (!data->ready) {
269                         error = -ENODATA;
270                         break;
271                 }
272                 size = snapshot_get_image_size();
273                 size <<= PAGE_SHIFT;
274                 error = put_user(size, (loff_t __user *)arg);
275                 break;
276
277         case SNAPSHOT_AVAIL_SWAP_SIZE:
278         case SNAPSHOT_AVAIL_SWAP:
279                 size = count_swap_pages(data->swap, 1);
280                 size <<= PAGE_SHIFT;
281                 error = put_user(size, (loff_t __user *)arg);
282                 break;
283
284         case SNAPSHOT_ALLOC_SWAP_PAGE:
285         case SNAPSHOT_GET_SWAP_PAGE:
286                 if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
287                         error = -ENODEV;
288                         break;
289                 }
290                 offset = alloc_swapdev_block(data->swap);
291                 if (offset) {
292                         offset <<= PAGE_SHIFT;
293                         error = put_user(offset, (loff_t __user *)arg);
294                 } else {
295                         error = -ENOSPC;
296                 }
297                 break;
298
299         case SNAPSHOT_FREE_SWAP_PAGES:
300                 if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
301                         error = -ENODEV;
302                         break;
303                 }
304                 free_all_swap_pages(data->swap);
305                 break;
306
307         case SNAPSHOT_SET_SWAP_FILE: /* This ioctl is deprecated */
308                 if (!swsusp_swap_in_use()) {
309                         /*
310                          * User space encodes device types as two-byte values,
311                          * so we need to recode them
312                          */
313                         if (old_decode_dev(arg)) {
314                                 data->swap = swap_type_of(old_decode_dev(arg),
315                                                         0, NULL);
316                                 if (data->swap < 0)
317                                         error = -ENODEV;
318                         } else {
319                                 data->swap = -1;
320                                 error = -EINVAL;
321                         }
322                 } else {
323                         error = -EPERM;
324                 }
325                 break;
326
327         case SNAPSHOT_S2RAM:
328                 if (!data->frozen) {
329                         error = -EPERM;
330                         break;
331                 }
332                 /*
333                  * Tasks are frozen and the notifiers have been called with
334                  * PM_HIBERNATION_PREPARE
335                  */
336                 error = suspend_devices_and_enter(PM_SUSPEND_MEM);
337                 break;
338
339         case SNAPSHOT_PLATFORM_SUPPORT:
340                 data->platform_support = !!arg;
341                 break;
342
343         case SNAPSHOT_POWER_OFF:
344                 if (data->platform_support)
345                         error = hibernation_platform_enter();
346                 break;
347
348         case SNAPSHOT_PMOPS: /* This ioctl is deprecated */
349                 error = -EINVAL;
350
351                 switch (arg) {
352
353                 case PMOPS_PREPARE:
354                         data->platform_support = 1;
355                         error = 0;
356                         break;
357
358                 case PMOPS_ENTER:
359                         if (data->platform_support)
360                                 error = hibernation_platform_enter();
361                         break;
362
363                 case PMOPS_FINISH:
364                         if (data->platform_support)
365                                 error = 0;
366                         break;
367
368                 default:
369                         printk(KERN_ERR "SNAPSHOT_PMOPS: invalid argument %ld\n", arg);
370
371                 }
372                 break;
373
374         case SNAPSHOT_SET_SWAP_AREA:
375                 if (swsusp_swap_in_use()) {
376                         error = -EPERM;
377                 } else {
378                         struct resume_swap_area swap_area;
379                         dev_t swdev;
380
381                         error = copy_from_user(&swap_area, (void __user *)arg,
382                                         sizeof(struct resume_swap_area));
383                         if (error) {
384                                 error = -EFAULT;
385                                 break;
386                         }
387
388                         /*
389                          * User space encodes device types as two-byte values,
390                          * so we need to recode them
391                          */
392                         swdev = old_decode_dev(swap_area.dev);
393                         if (swdev) {
394                                 offset = swap_area.offset;
395                                 data->swap = swap_type_of(swdev, offset, NULL);
396                                 if (data->swap < 0)
397                                         error = -ENODEV;
398                         } else {
399                                 data->swap = -1;
400                                 error = -EINVAL;
401                         }
402                 }
403                 break;
404
405         default:
406                 error = -ENOTTY;
407
408         }
409
410         mutex_unlock(&pm_mutex);
411
412         return error;
413 }
414
415 static const struct file_operations snapshot_fops = {
416         .open = snapshot_open,
417         .release = snapshot_release,
418         .read = snapshot_read,
419         .write = snapshot_write,
420         .llseek = no_llseek,
421         .unlocked_ioctl = snapshot_ioctl,
422 };
423
424 static struct miscdevice snapshot_device = {
425         .minor = SNAPSHOT_MINOR,
426         .name = "snapshot",
427         .fops = &snapshot_fops,
428 };
429
430 static int __init snapshot_device_init(void)
431 {
432         return misc_register(&snapshot_device);
433 };
434
435 device_initcall(snapshot_device_init);