]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - kernel/power/user.c
Driver core: Don't call put methods while holding a spinlock
[linux-2.6.git] / 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/string.h>
15 #include <linux/device.h>
16 #include <linux/miscdevice.h>
17 #include <linux/mm.h>
18 #include <linux/swap.h>
19 #include <linux/swapops.h>
20 #include <linux/pm.h>
21 #include <linux/fs.h>
22
23 #include <asm/uaccess.h>
24
25 #include "power.h"
26
27 #define SNAPSHOT_MINOR  231
28
29 static struct snapshot_data {
30         struct snapshot_handle handle;
31         int swap;
32         struct bitmap_page *bitmap;
33         int mode;
34         char frozen;
35         char ready;
36 } snapshot_state;
37
38 static atomic_t device_available = ATOMIC_INIT(1);
39
40 static int snapshot_open(struct inode *inode, struct file *filp)
41 {
42         struct snapshot_data *data;
43
44         if (!atomic_add_unless(&device_available, -1, 0))
45                 return -EBUSY;
46
47         if ((filp->f_flags & O_ACCMODE) == O_RDWR)
48                 return -ENOSYS;
49
50         nonseekable_open(inode, filp);
51         data = &snapshot_state;
52         filp->private_data = data;
53         memset(&data->handle, 0, sizeof(struct snapshot_handle));
54         if ((filp->f_flags & O_ACCMODE) == O_RDONLY) {
55                 data->swap = swsusp_resume_device ? swap_type_of(swsusp_resume_device) : -1;
56                 data->mode = O_RDONLY;
57         } else {
58                 data->swap = -1;
59                 data->mode = O_WRONLY;
60         }
61         data->bitmap = NULL;
62         data->frozen = 0;
63         data->ready = 0;
64
65         return 0;
66 }
67
68 static int snapshot_release(struct inode *inode, struct file *filp)
69 {
70         struct snapshot_data *data;
71
72         swsusp_free();
73         data = filp->private_data;
74         free_all_swap_pages(data->swap, data->bitmap);
75         free_bitmap(data->bitmap);
76         if (data->frozen) {
77                 down(&pm_sem);
78                 thaw_processes();
79                 enable_nonboot_cpus();
80                 up(&pm_sem);
81         }
82         atomic_inc(&device_available);
83         return 0;
84 }
85
86 static ssize_t snapshot_read(struct file *filp, char __user *buf,
87                              size_t count, loff_t *offp)
88 {
89         struct snapshot_data *data;
90         ssize_t res;
91
92         data = filp->private_data;
93         res = snapshot_read_next(&data->handle, count);
94         if (res > 0) {
95                 if (copy_to_user(buf, data_of(data->handle), res))
96                         res = -EFAULT;
97                 else
98                         *offp = data->handle.offset;
99         }
100         return res;
101 }
102
103 static ssize_t snapshot_write(struct file *filp, const char __user *buf,
104                               size_t count, loff_t *offp)
105 {
106         struct snapshot_data *data;
107         ssize_t res;
108
109         data = filp->private_data;
110         res = snapshot_write_next(&data->handle, count);
111         if (res > 0) {
112                 if (copy_from_user(data_of(data->handle), buf, res))
113                         res = -EFAULT;
114                 else
115                         *offp = data->handle.offset;
116         }
117         return res;
118 }
119
120 static int snapshot_ioctl(struct inode *inode, struct file *filp,
121                           unsigned int cmd, unsigned long arg)
122 {
123         int error = 0;
124         struct snapshot_data *data;
125         loff_t offset, avail;
126
127         if (_IOC_TYPE(cmd) != SNAPSHOT_IOC_MAGIC)
128                 return -ENOTTY;
129         if (_IOC_NR(cmd) > SNAPSHOT_IOC_MAXNR)
130                 return -ENOTTY;
131         if (!capable(CAP_SYS_ADMIN))
132                 return -EPERM;
133
134         data = filp->private_data;
135
136         switch (cmd) {
137
138         case SNAPSHOT_FREEZE:
139                 if (data->frozen)
140                         break;
141                 down(&pm_sem);
142                 disable_nonboot_cpus();
143                 if (freeze_processes()) {
144                         thaw_processes();
145                         enable_nonboot_cpus();
146                         error = -EBUSY;
147                 }
148                 up(&pm_sem);
149                 if (!error)
150                         data->frozen = 1;
151                 break;
152
153         case SNAPSHOT_UNFREEZE:
154                 if (!data->frozen)
155                         break;
156                 down(&pm_sem);
157                 thaw_processes();
158                 enable_nonboot_cpus();
159                 up(&pm_sem);
160                 data->frozen = 0;
161                 break;
162
163         case SNAPSHOT_ATOMIC_SNAPSHOT:
164                 if (data->mode != O_RDONLY || !data->frozen  || data->ready) {
165                         error = -EPERM;
166                         break;
167                 }
168                 down(&pm_sem);
169                 /* Free memory before shutting down devices. */
170                 error = swsusp_shrink_memory();
171                 if (!error) {
172                         error = device_suspend(PMSG_FREEZE);
173                         if (!error) {
174                                 in_suspend = 1;
175                                 error = swsusp_suspend();
176                                 device_resume();
177                         }
178                 }
179                 up(&pm_sem);
180                 if (!error)
181                         error = put_user(in_suspend, (unsigned int __user *)arg);
182                 if (!error)
183                         data->ready = 1;
184                 break;
185
186         case SNAPSHOT_ATOMIC_RESTORE:
187                 if (data->mode != O_WRONLY || !data->frozen ||
188                     !snapshot_image_loaded(&data->handle)) {
189                         error = -EPERM;
190                         break;
191                 }
192                 down(&pm_sem);
193                 pm_prepare_console();
194                 error = device_suspend(PMSG_PRETHAW);
195                 if (!error) {
196                         error = swsusp_resume();
197                         device_resume();
198                 }
199                 pm_restore_console();
200                 up(&pm_sem);
201                 break;
202
203         case SNAPSHOT_FREE:
204                 swsusp_free();
205                 memset(&data->handle, 0, sizeof(struct snapshot_handle));
206                 data->ready = 0;
207                 break;
208
209         case SNAPSHOT_SET_IMAGE_SIZE:
210                 image_size = arg;
211                 break;
212
213         case SNAPSHOT_AVAIL_SWAP:
214                 avail = count_swap_pages(data->swap, 1);
215                 avail <<= PAGE_SHIFT;
216                 error = put_user(avail, (loff_t __user *)arg);
217                 break;
218
219         case SNAPSHOT_GET_SWAP_PAGE:
220                 if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
221                         error = -ENODEV;
222                         break;
223                 }
224                 if (!data->bitmap) {
225                         data->bitmap = alloc_bitmap(count_swap_pages(data->swap, 0));
226                         if (!data->bitmap) {
227                                 error = -ENOMEM;
228                                 break;
229                         }
230                 }
231                 offset = alloc_swap_page(data->swap, data->bitmap);
232                 if (offset) {
233                         offset <<= PAGE_SHIFT;
234                         error = put_user(offset, (loff_t __user *)arg);
235                 } else {
236                         error = -ENOSPC;
237                 }
238                 break;
239
240         case SNAPSHOT_FREE_SWAP_PAGES:
241                 if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
242                         error = -ENODEV;
243                         break;
244                 }
245                 free_all_swap_pages(data->swap, data->bitmap);
246                 free_bitmap(data->bitmap);
247                 data->bitmap = NULL;
248                 break;
249
250         case SNAPSHOT_SET_SWAP_FILE:
251                 if (!data->bitmap) {
252                         /*
253                          * User space encodes device types as two-byte values,
254                          * so we need to recode them
255                          */
256                         if (old_decode_dev(arg)) {
257                                 data->swap = swap_type_of(old_decode_dev(arg));
258                                 if (data->swap < 0)
259                                         error = -ENODEV;
260                         } else {
261                                 data->swap = -1;
262                                 error = -EINVAL;
263                         }
264                 } else {
265                         error = -EPERM;
266                 }
267                 break;
268
269         case SNAPSHOT_S2RAM:
270                 if (!data->frozen) {
271                         error = -EPERM;
272                         break;
273                 }
274
275                 if (down_trylock(&pm_sem)) {
276                         error = -EBUSY;
277                         break;
278                 }
279
280                 if (pm_ops->prepare) {
281                         error = pm_ops->prepare(PM_SUSPEND_MEM);
282                         if (error)
283                                 goto OutS3;
284                 }
285
286                 /* Put devices to sleep */
287                 error = device_suspend(PMSG_SUSPEND);
288                 if (error) {
289                         printk(KERN_ERR "Failed to suspend some devices.\n");
290                 } else {
291                         /* Enter S3, system is already frozen */
292                         suspend_enter(PM_SUSPEND_MEM);
293
294                         /* Wake up devices */
295                         device_resume();
296                 }
297
298                 if (pm_ops->finish)
299                         pm_ops->finish(PM_SUSPEND_MEM);
300
301 OutS3:
302                 up(&pm_sem);
303                 break;
304
305         default:
306                 error = -ENOTTY;
307
308         }
309
310         return error;
311 }
312
313 static struct file_operations snapshot_fops = {
314         .open = snapshot_open,
315         .release = snapshot_release,
316         .read = snapshot_read,
317         .write = snapshot_write,
318         .llseek = no_llseek,
319         .ioctl = snapshot_ioctl,
320 };
321
322 static struct miscdevice snapshot_device = {
323         .minor = SNAPSHOT_MINOR,
324         .name = "snapshot",
325         .fops = &snapshot_fops,
326 };
327
328 static int __init snapshot_device_init(void)
329 {
330         return misc_register(&snapshot_device);
331 };
332
333 device_initcall(snapshot_device_init);