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