[PATCH] convert pm_sem to a mutex
[linux-2.6.git] / kernel / power / disk.c
1 /*
2  * kernel/power/disk.c - Suspend-to-disk support.
3  *
4  * Copyright (c) 2003 Patrick Mochel
5  * Copyright (c) 2003 Open Source Development Lab
6  * Copyright (c) 2004 Pavel Machek <pavel@suse.cz>
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/delay.h>
18 #include <linux/fs.h>
19 #include <linux/mount.h>
20 #include <linux/pm.h>
21 #include <linux/console.h>
22 #include <linux/cpu.h>
23 #include <linux/freezer.h>
24
25 #include "power.h"
26
27
28 static int noresume = 0;
29 char resume_file[256] = CONFIG_PM_STD_PARTITION;
30 dev_t swsusp_resume_device;
31 sector_t swsusp_resume_block;
32
33 /**
34  *      platform_prepare - prepare the machine for hibernation using the
35  *      platform driver if so configured and return an error code if it fails
36  */
37
38 static inline int platform_prepare(void)
39 {
40         int error = 0;
41
42         if (pm_disk_mode == PM_DISK_PLATFORM) {
43                 if (pm_ops && pm_ops->prepare)
44                         error = pm_ops->prepare(PM_SUSPEND_DISK);
45         }
46         return error;
47 }
48
49 /**
50  *      power_down - Shut machine down for hibernate.
51  *      @mode:          Suspend-to-disk mode
52  *
53  *      Use the platform driver, if configured so, and return gracefully if it
54  *      fails.
55  *      Otherwise, try to power off and reboot. If they fail, halt the machine,
56  *      there ain't no turning back.
57  */
58
59 static void power_down(suspend_disk_method_t mode)
60 {
61         int error = 0;
62
63         switch(mode) {
64         case PM_DISK_PLATFORM:
65                 kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
66                 error = pm_ops->enter(PM_SUSPEND_DISK);
67                 break;
68         case PM_DISK_SHUTDOWN:
69                 kernel_power_off();
70                 break;
71         case PM_DISK_REBOOT:
72                 kernel_restart(NULL);
73                 break;
74         }
75         kernel_halt();
76         /* Valid image is on the disk, if we continue we risk serious data corruption
77            after resume. */
78         printk(KERN_CRIT "Please power me down manually\n");
79         while(1);
80 }
81
82 static inline void platform_finish(void)
83 {
84         if (pm_disk_mode == PM_DISK_PLATFORM) {
85                 if (pm_ops && pm_ops->finish)
86                         pm_ops->finish(PM_SUSPEND_DISK);
87         }
88 }
89
90 static int prepare_processes(void)
91 {
92         int error = 0;
93
94         pm_prepare_console();
95
96         error = disable_nonboot_cpus();
97         if (error)
98                 goto enable_cpus;
99
100         if (freeze_processes()) {
101                 error = -EBUSY;
102                 goto thaw;
103         }
104
105         if (pm_disk_mode == PM_DISK_TESTPROC) {
106                 printk("swsusp debug: Waiting for 5 seconds.\n");
107                 mdelay(5000);
108                 goto thaw;
109         }
110
111         error = platform_prepare();
112         if (error)
113                 goto thaw;
114
115         /* Free memory before shutting down devices. */
116         if (!(error = swsusp_shrink_memory()))
117                 return 0;
118
119         platform_finish();
120 thaw:
121         thaw_processes();
122 enable_cpus:
123         enable_nonboot_cpus();
124         pm_restore_console();
125         return error;
126 }
127
128 static void unprepare_processes(void)
129 {
130         platform_finish();
131         thaw_processes();
132         enable_nonboot_cpus();
133         pm_restore_console();
134 }
135
136 /**
137  *      pm_suspend_disk - The granpappy of hibernation power management.
138  *
139  *      If we're going through the firmware, then get it over with quickly.
140  *
141  *      If not, then call swsusp to do its thing, then figure out how
142  *      to power down the system.
143  */
144
145 int pm_suspend_disk(void)
146 {
147         int error;
148
149         error = prepare_processes();
150         if (error)
151                 return error;
152
153         if (pm_disk_mode == PM_DISK_TESTPROC)
154                 goto Thaw;
155
156         suspend_console();
157         error = device_suspend(PMSG_FREEZE);
158         if (error) {
159                 resume_console();
160                 printk("Some devices failed to suspend\n");
161                 goto Thaw;
162         }
163
164         if (pm_disk_mode == PM_DISK_TEST) {
165                 printk("swsusp debug: Waiting for 5 seconds.\n");
166                 mdelay(5000);
167                 goto Done;
168         }
169
170         pr_debug("PM: snapshotting memory.\n");
171         in_suspend = 1;
172         if ((error = swsusp_suspend()))
173                 goto Done;
174
175         if (in_suspend) {
176                 device_resume();
177                 resume_console();
178                 pr_debug("PM: writing image.\n");
179                 error = swsusp_write();
180                 if (!error)
181                         power_down(pm_disk_mode);
182                 else {
183                         swsusp_free();
184                         goto Thaw;
185                 }
186         } else {
187                 pr_debug("PM: Image restored successfully.\n");
188         }
189
190         swsusp_free();
191  Done:
192         device_resume();
193         resume_console();
194  Thaw:
195         unprepare_processes();
196         return error;
197 }
198
199
200 /**
201  *      software_resume - Resume from a saved image.
202  *
203  *      Called as a late_initcall (so all devices are discovered and
204  *      initialized), we call swsusp to see if we have a saved image or not.
205  *      If so, we quiesce devices, the restore the saved image. We will
206  *      return above (in pm_suspend_disk() ) if everything goes well.
207  *      Otherwise, we fail gracefully and return to the normally
208  *      scheduled program.
209  *
210  */
211
212 static int software_resume(void)
213 {
214         int error;
215
216         mutex_lock(&pm_mutex);
217         if (!swsusp_resume_device) {
218                 if (!strlen(resume_file)) {
219                         mutex_unlock(&pm_mutex);
220                         return -ENOENT;
221                 }
222                 swsusp_resume_device = name_to_dev_t(resume_file);
223                 pr_debug("swsusp: Resume From Partition %s\n", resume_file);
224         } else {
225                 pr_debug("swsusp: Resume From Partition %d:%d\n",
226                          MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
227         }
228
229         if (noresume) {
230                 /**
231                  * FIXME: If noresume is specified, we need to find the partition
232                  * and reset it back to normal swap space.
233                  */
234                 mutex_unlock(&pm_mutex);
235                 return 0;
236         }
237
238         pr_debug("PM: Checking swsusp image.\n");
239
240         if ((error = swsusp_check()))
241                 goto Done;
242
243         pr_debug("PM: Preparing processes for restore.\n");
244
245         if ((error = prepare_processes())) {
246                 swsusp_close();
247                 goto Done;
248         }
249
250         pr_debug("PM: Reading swsusp image.\n");
251
252         if ((error = swsusp_read())) {
253                 swsusp_free();
254                 goto Thaw;
255         }
256
257         pr_debug("PM: Preparing devices for restore.\n");
258
259         suspend_console();
260         if ((error = device_suspend(PMSG_PRETHAW))) {
261                 resume_console();
262                 printk("Some devices failed to suspend\n");
263                 swsusp_free();
264                 goto Thaw;
265         }
266
267         mb();
268
269         pr_debug("PM: Restoring saved image.\n");
270         swsusp_resume();
271         pr_debug("PM: Restore failed, recovering.n");
272         device_resume();
273         resume_console();
274  Thaw:
275         unprepare_processes();
276  Done:
277         /* For success case, the suspend path will release the lock */
278         mutex_unlock(&pm_mutex);
279         pr_debug("PM: Resume from disk failed.\n");
280         return 0;
281 }
282
283 late_initcall(software_resume);
284
285
286 static const char * const pm_disk_modes[] = {
287         [PM_DISK_FIRMWARE]      = "firmware",
288         [PM_DISK_PLATFORM]      = "platform",
289         [PM_DISK_SHUTDOWN]      = "shutdown",
290         [PM_DISK_REBOOT]        = "reboot",
291         [PM_DISK_TEST]          = "test",
292         [PM_DISK_TESTPROC]      = "testproc",
293 };
294
295 /**
296  *      disk - Control suspend-to-disk mode
297  *
298  *      Suspend-to-disk can be handled in several ways. The greatest
299  *      distinction is who writes memory to disk - the firmware or the OS.
300  *      If the firmware does it, we assume that it also handles suspending
301  *      the system.
302  *      If the OS does it, then we have three options for putting the system
303  *      to sleep - using the platform driver (e.g. ACPI or other PM registers),
304  *      powering off the system or rebooting the system (for testing).
305  *
306  *      The system will support either 'firmware' or 'platform', and that is
307  *      known a priori (and encoded in pm_ops). But, the user may choose
308  *      'shutdown' or 'reboot' as alternatives.
309  *
310  *      show() will display what the mode is currently set to.
311  *      store() will accept one of
312  *
313  *      'firmware'
314  *      'platform'
315  *      'shutdown'
316  *      'reboot'
317  *
318  *      It will only change to 'firmware' or 'platform' if the system
319  *      supports it (as determined from pm_ops->pm_disk_mode).
320  */
321
322 static ssize_t disk_show(struct subsystem * subsys, char * buf)
323 {
324         return sprintf(buf, "%s\n", pm_disk_modes[pm_disk_mode]);
325 }
326
327
328 static ssize_t disk_store(struct subsystem * s, const char * buf, size_t n)
329 {
330         int error = 0;
331         int i;
332         int len;
333         char *p;
334         suspend_disk_method_t mode = 0;
335
336         p = memchr(buf, '\n', n);
337         len = p ? p - buf : n;
338
339         mutex_lock(&pm_mutex);
340         for (i = PM_DISK_FIRMWARE; i < PM_DISK_MAX; i++) {
341                 if (!strncmp(buf, pm_disk_modes[i], len)) {
342                         mode = i;
343                         break;
344                 }
345         }
346         if (mode) {
347                 if (mode == PM_DISK_SHUTDOWN || mode == PM_DISK_REBOOT ||
348                      mode == PM_DISK_TEST || mode == PM_DISK_TESTPROC) {
349                         pm_disk_mode = mode;
350                 } else {
351                         if (pm_ops && pm_ops->enter &&
352                             (mode == pm_ops->pm_disk_mode))
353                                 pm_disk_mode = mode;
354                         else
355                                 error = -EINVAL;
356                 }
357         } else {
358                 error = -EINVAL;
359         }
360
361         pr_debug("PM: suspend-to-disk mode set to '%s'\n",
362                  pm_disk_modes[mode]);
363         mutex_unlock(&pm_mutex);
364         return error ? error : n;
365 }
366
367 power_attr(disk);
368
369 static ssize_t resume_show(struct subsystem * subsys, char *buf)
370 {
371         return sprintf(buf,"%d:%d\n", MAJOR(swsusp_resume_device),
372                        MINOR(swsusp_resume_device));
373 }
374
375 static ssize_t resume_store(struct subsystem *subsys, const char *buf, size_t n)
376 {
377         unsigned int maj, min;
378         dev_t res;
379         int ret = -EINVAL;
380
381         if (sscanf(buf, "%u:%u", &maj, &min) != 2)
382                 goto out;
383
384         res = MKDEV(maj,min);
385         if (maj != MAJOR(res) || min != MINOR(res))
386                 goto out;
387
388         mutex_lock(&pm_mutex);
389         swsusp_resume_device = res;
390         mutex_unlock(&pm_mutex);
391         printk("Attempting manual resume\n");
392         noresume = 0;
393         software_resume();
394         ret = n;
395 out:
396         return ret;
397 }
398
399 power_attr(resume);
400
401 static ssize_t image_size_show(struct subsystem * subsys, char *buf)
402 {
403         return sprintf(buf, "%lu\n", image_size);
404 }
405
406 static ssize_t image_size_store(struct subsystem * subsys, const char * buf, size_t n)
407 {
408         unsigned long size;
409
410         if (sscanf(buf, "%lu", &size) == 1) {
411                 image_size = size;
412                 return n;
413         }
414
415         return -EINVAL;
416 }
417
418 power_attr(image_size);
419
420 static struct attribute * g[] = {
421         &disk_attr.attr,
422         &resume_attr.attr,
423         &image_size_attr.attr,
424         NULL,
425 };
426
427
428 static struct attribute_group attr_group = {
429         .attrs = g,
430 };
431
432
433 static int __init pm_disk_init(void)
434 {
435         return sysfs_create_group(&power_subsys.kset.kobj,&attr_group);
436 }
437
438 core_initcall(pm_disk_init);
439
440
441 static int __init resume_setup(char *str)
442 {
443         if (noresume)
444                 return 1;
445
446         strncpy( resume_file, str, 255 );
447         return 1;
448 }
449
450 static int __init resume_offset_setup(char *str)
451 {
452         unsigned long long offset;
453
454         if (noresume)
455                 return 1;
456
457         if (sscanf(str, "%llu", &offset) == 1)
458                 swsusp_resume_block = offset;
459
460         return 1;
461 }
462
463 static int __init noresume_setup(char *str)
464 {
465         noresume = 1;
466         return 1;
467 }
468
469 __setup("noresume", noresume_setup);
470 __setup("resume_offset=", resume_offset_setup);
471 __setup("resume=", resume_setup);