xref: /linux/kernel/power/hibernate.c (revision 643161ace2a7624fd0106ede12ae43bcbbfc1de0)
1 /*
2  * kernel/power/hibernate.c - Hibernation (a.k.a 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@ucw.cz>
7  * Copyright (c) 2009 Rafael J. Wysocki, Novell Inc.
8  *
9  * This file is released under the GPLv2.
10  */
11 
12 #include <linux/export.h>
13 #include <linux/suspend.h>
14 #include <linux/syscalls.h>
15 #include <linux/reboot.h>
16 #include <linux/string.h>
17 #include <linux/device.h>
18 #include <linux/async.h>
19 #include <linux/kmod.h>
20 #include <linux/delay.h>
21 #include <linux/fs.h>
22 #include <linux/mount.h>
23 #include <linux/pm.h>
24 #include <linux/console.h>
25 #include <linux/cpu.h>
26 #include <linux/freezer.h>
27 #include <linux/gfp.h>
28 #include <linux/syscore_ops.h>
29 #include <scsi/scsi_scan.h>
30 
31 #include "power.h"
32 
33 
34 static int nocompress;
35 static int noresume;
36 static int resume_wait;
37 static int resume_delay;
38 static char resume_file[256] = CONFIG_PM_STD_PARTITION;
39 dev_t swsusp_resume_device;
40 sector_t swsusp_resume_block;
41 int in_suspend __nosavedata;
42 
43 enum {
44 	HIBERNATION_INVALID,
45 	HIBERNATION_PLATFORM,
46 	HIBERNATION_SHUTDOWN,
47 	HIBERNATION_REBOOT,
48 	/* keep last */
49 	__HIBERNATION_AFTER_LAST
50 };
51 #define HIBERNATION_MAX (__HIBERNATION_AFTER_LAST-1)
52 #define HIBERNATION_FIRST (HIBERNATION_INVALID + 1)
53 
54 static int hibernation_mode = HIBERNATION_SHUTDOWN;
55 
56 bool freezer_test_done;
57 
58 static const struct platform_hibernation_ops *hibernation_ops;
59 
60 /**
61  * hibernation_set_ops - Set the global hibernate operations.
62  * @ops: Hibernation operations to use in subsequent hibernation transitions.
63  */
64 void hibernation_set_ops(const struct platform_hibernation_ops *ops)
65 {
66 	if (ops && !(ops->begin && ops->end &&  ops->pre_snapshot
67 	    && ops->prepare && ops->finish && ops->enter && ops->pre_restore
68 	    && ops->restore_cleanup && ops->leave)) {
69 		WARN_ON(1);
70 		return;
71 	}
72 	lock_system_sleep();
73 	hibernation_ops = ops;
74 	if (ops)
75 		hibernation_mode = HIBERNATION_PLATFORM;
76 	else if (hibernation_mode == HIBERNATION_PLATFORM)
77 		hibernation_mode = HIBERNATION_SHUTDOWN;
78 
79 	unlock_system_sleep();
80 }
81 
82 static bool entering_platform_hibernation;
83 
84 bool system_entering_hibernation(void)
85 {
86 	return entering_platform_hibernation;
87 }
88 EXPORT_SYMBOL(system_entering_hibernation);
89 
90 #ifdef CONFIG_PM_DEBUG
91 static void hibernation_debug_sleep(void)
92 {
93 	printk(KERN_INFO "hibernation debug: Waiting for 5 seconds.\n");
94 	mdelay(5000);
95 }
96 
97 static int hibernation_test(int level)
98 {
99 	if (pm_test_level == level) {
100 		hibernation_debug_sleep();
101 		return 1;
102 	}
103 	return 0;
104 }
105 #else /* !CONFIG_PM_DEBUG */
106 static int hibernation_test(int level) { return 0; }
107 #endif /* !CONFIG_PM_DEBUG */
108 
109 /**
110  * platform_begin - Call platform to start hibernation.
111  * @platform_mode: Whether or not to use the platform driver.
112  */
113 static int platform_begin(int platform_mode)
114 {
115 	return (platform_mode && hibernation_ops) ?
116 		hibernation_ops->begin() : 0;
117 }
118 
119 /**
120  * platform_end - Call platform to finish transition to the working state.
121  * @platform_mode: Whether or not to use the platform driver.
122  */
123 static void platform_end(int platform_mode)
124 {
125 	if (platform_mode && hibernation_ops)
126 		hibernation_ops->end();
127 }
128 
129 /**
130  * platform_pre_snapshot - Call platform to prepare the machine for hibernation.
131  * @platform_mode: Whether or not to use the platform driver.
132  *
133  * Use the platform driver to prepare the system for creating a hibernate image,
134  * if so configured, and return an error code if that fails.
135  */
136 
137 static int platform_pre_snapshot(int platform_mode)
138 {
139 	return (platform_mode && hibernation_ops) ?
140 		hibernation_ops->pre_snapshot() : 0;
141 }
142 
143 /**
144  * platform_leave - Call platform to prepare a transition to the working state.
145  * @platform_mode: Whether or not to use the platform driver.
146  *
147  * Use the platform driver prepare to prepare the machine for switching to the
148  * normal mode of operation.
149  *
150  * This routine is called on one CPU with interrupts disabled.
151  */
152 static void platform_leave(int platform_mode)
153 {
154 	if (platform_mode && hibernation_ops)
155 		hibernation_ops->leave();
156 }
157 
158 /**
159  * platform_finish - Call platform to switch the system to the working state.
160  * @platform_mode: Whether or not to use the platform driver.
161  *
162  * Use the platform driver to switch the machine to the normal mode of
163  * operation.
164  *
165  * This routine must be called after platform_prepare().
166  */
167 static void platform_finish(int platform_mode)
168 {
169 	if (platform_mode && hibernation_ops)
170 		hibernation_ops->finish();
171 }
172 
173 /**
174  * platform_pre_restore - Prepare for hibernate image restoration.
175  * @platform_mode: Whether or not to use the platform driver.
176  *
177  * Use the platform driver to prepare the system for resume from a hibernation
178  * image.
179  *
180  * If the restore fails after this function has been called,
181  * platform_restore_cleanup() must be called.
182  */
183 static int platform_pre_restore(int platform_mode)
184 {
185 	return (platform_mode && hibernation_ops) ?
186 		hibernation_ops->pre_restore() : 0;
187 }
188 
189 /**
190  * platform_restore_cleanup - Switch to the working state after failing restore.
191  * @platform_mode: Whether or not to use the platform driver.
192  *
193  * Use the platform driver to switch the system to the normal mode of operation
194  * after a failing restore.
195  *
196  * If platform_pre_restore() has been called before the failing restore, this
197  * function must be called too, regardless of the result of
198  * platform_pre_restore().
199  */
200 static void platform_restore_cleanup(int platform_mode)
201 {
202 	if (platform_mode && hibernation_ops)
203 		hibernation_ops->restore_cleanup();
204 }
205 
206 /**
207  * platform_recover - Recover from a failure to suspend devices.
208  * @platform_mode: Whether or not to use the platform driver.
209  */
210 static void platform_recover(int platform_mode)
211 {
212 	if (platform_mode && hibernation_ops && hibernation_ops->recover)
213 		hibernation_ops->recover();
214 }
215 
216 /**
217  * swsusp_show_speed - Print time elapsed between two events during hibernation.
218  * @start: Starting event.
219  * @stop: Final event.
220  * @nr_pages: Number of memory pages processed between @start and @stop.
221  * @msg: Additional diagnostic message to print.
222  */
223 void swsusp_show_speed(struct timeval *start, struct timeval *stop,
224 			unsigned nr_pages, char *msg)
225 {
226 	s64 elapsed_centisecs64;
227 	int centisecs;
228 	int k;
229 	int kps;
230 
231 	elapsed_centisecs64 = timeval_to_ns(stop) - timeval_to_ns(start);
232 	do_div(elapsed_centisecs64, NSEC_PER_SEC / 100);
233 	centisecs = elapsed_centisecs64;
234 	if (centisecs == 0)
235 		centisecs = 1;	/* avoid div-by-zero */
236 	k = nr_pages * (PAGE_SIZE / 1024);
237 	kps = (k * 100) / centisecs;
238 	printk(KERN_INFO "PM: %s %d kbytes in %d.%02d seconds (%d.%02d MB/s)\n",
239 			msg, k,
240 			centisecs / 100, centisecs % 100,
241 			kps / 1000, (kps % 1000) / 10);
242 }
243 
244 /**
245  * create_image - Create a hibernation image.
246  * @platform_mode: Whether or not to use the platform driver.
247  *
248  * Execute device drivers' "late" and "noirq" freeze callbacks, create a
249  * hibernation image and run the drivers' "noirq" and "early" thaw callbacks.
250  *
251  * Control reappears in this routine after the subsequent restore.
252  */
253 static int create_image(int platform_mode)
254 {
255 	int error;
256 
257 	error = dpm_suspend_end(PMSG_FREEZE);
258 	if (error) {
259 		printk(KERN_ERR "PM: Some devices failed to power down, "
260 			"aborting hibernation\n");
261 		return error;
262 	}
263 
264 	error = platform_pre_snapshot(platform_mode);
265 	if (error || hibernation_test(TEST_PLATFORM))
266 		goto Platform_finish;
267 
268 	error = disable_nonboot_cpus();
269 	if (error || hibernation_test(TEST_CPUS))
270 		goto Enable_cpus;
271 
272 	local_irq_disable();
273 
274 	error = syscore_suspend();
275 	if (error) {
276 		printk(KERN_ERR "PM: Some system devices failed to power down, "
277 			"aborting hibernation\n");
278 		goto Enable_irqs;
279 	}
280 
281 	if (hibernation_test(TEST_CORE) || pm_wakeup_pending())
282 		goto Power_up;
283 
284 	in_suspend = 1;
285 	save_processor_state();
286 	error = swsusp_arch_suspend();
287 	if (error)
288 		printk(KERN_ERR "PM: Error %d creating hibernation image\n",
289 			error);
290 	/* Restore control flow magically appears here */
291 	restore_processor_state();
292 	if (!in_suspend) {
293 		events_check_enabled = false;
294 		platform_leave(platform_mode);
295 	}
296 
297  Power_up:
298 	syscore_resume();
299 
300  Enable_irqs:
301 	local_irq_enable();
302 
303  Enable_cpus:
304 	enable_nonboot_cpus();
305 
306  Platform_finish:
307 	platform_finish(platform_mode);
308 
309 	dpm_resume_start(in_suspend ?
310 		(error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
311 
312 	return error;
313 }
314 
315 /**
316  * hibernation_snapshot - Quiesce devices and create a hibernation image.
317  * @platform_mode: If set, use platform driver to prepare for the transition.
318  *
319  * This routine must be called with pm_mutex held.
320  */
321 int hibernation_snapshot(int platform_mode)
322 {
323 	pm_message_t msg;
324 	int error;
325 
326 	error = platform_begin(platform_mode);
327 	if (error)
328 		goto Close;
329 
330 	/* Preallocate image memory before shutting down devices. */
331 	error = hibernate_preallocate_memory();
332 	if (error)
333 		goto Close;
334 
335 	error = freeze_kernel_threads();
336 	if (error)
337 		goto Cleanup;
338 
339 	if (hibernation_test(TEST_FREEZER)) {
340 
341 		/*
342 		 * Indicate to the caller that we are returning due to a
343 		 * successful freezer test.
344 		 */
345 		freezer_test_done = true;
346 		goto Thaw;
347 	}
348 
349 	error = dpm_prepare(PMSG_FREEZE);
350 	if (error) {
351 		dpm_complete(PMSG_RECOVER);
352 		goto Thaw;
353 	}
354 
355 	suspend_console();
356 	pm_restrict_gfp_mask();
357 
358 	error = dpm_suspend(PMSG_FREEZE);
359 
360 	if (error || hibernation_test(TEST_DEVICES))
361 		platform_recover(platform_mode);
362 	else
363 		error = create_image(platform_mode);
364 
365 	/*
366 	 * In the case that we call create_image() above, the control
367 	 * returns here (1) after the image has been created or the
368 	 * image creation has failed and (2) after a successful restore.
369 	 */
370 
371 	/* We may need to release the preallocated image pages here. */
372 	if (error || !in_suspend)
373 		swsusp_free();
374 
375 	msg = in_suspend ? (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE;
376 	dpm_resume(msg);
377 
378 	if (error || !in_suspend)
379 		pm_restore_gfp_mask();
380 
381 	resume_console();
382 	dpm_complete(msg);
383 
384  Close:
385 	platform_end(platform_mode);
386 	return error;
387 
388  Thaw:
389 	thaw_kernel_threads();
390  Cleanup:
391 	swsusp_free();
392 	goto Close;
393 }
394 
395 /**
396  * resume_target_kernel - Restore system state from a hibernation image.
397  * @platform_mode: Whether or not to use the platform driver.
398  *
399  * Execute device drivers' "noirq" and "late" freeze callbacks, restore the
400  * contents of highmem that have not been restored yet from the image and run
401  * the low-level code that will restore the remaining contents of memory and
402  * switch to the just restored target kernel.
403  */
404 static int resume_target_kernel(bool platform_mode)
405 {
406 	int error;
407 
408 	error = dpm_suspend_end(PMSG_QUIESCE);
409 	if (error) {
410 		printk(KERN_ERR "PM: Some devices failed to power down, "
411 			"aborting resume\n");
412 		return error;
413 	}
414 
415 	error = platform_pre_restore(platform_mode);
416 	if (error)
417 		goto Cleanup;
418 
419 	error = disable_nonboot_cpus();
420 	if (error)
421 		goto Enable_cpus;
422 
423 	local_irq_disable();
424 
425 	error = syscore_suspend();
426 	if (error)
427 		goto Enable_irqs;
428 
429 	save_processor_state();
430 	error = restore_highmem();
431 	if (!error) {
432 		error = swsusp_arch_resume();
433 		/*
434 		 * The code below is only ever reached in case of a failure.
435 		 * Otherwise, execution continues at the place where
436 		 * swsusp_arch_suspend() was called.
437 		 */
438 		BUG_ON(!error);
439 		/*
440 		 * This call to restore_highmem() reverts the changes made by
441 		 * the previous one.
442 		 */
443 		restore_highmem();
444 	}
445 	/*
446 	 * The only reason why swsusp_arch_resume() can fail is memory being
447 	 * very tight, so we have to free it as soon as we can to avoid
448 	 * subsequent failures.
449 	 */
450 	swsusp_free();
451 	restore_processor_state();
452 	touch_softlockup_watchdog();
453 
454 	syscore_resume();
455 
456  Enable_irqs:
457 	local_irq_enable();
458 
459  Enable_cpus:
460 	enable_nonboot_cpus();
461 
462  Cleanup:
463 	platform_restore_cleanup(platform_mode);
464 
465 	dpm_resume_start(PMSG_RECOVER);
466 
467 	return error;
468 }
469 
470 /**
471  * hibernation_restore - Quiesce devices and restore from a hibernation image.
472  * @platform_mode: If set, use platform driver to prepare for the transition.
473  *
474  * This routine must be called with pm_mutex held.  If it is successful, control
475  * reappears in the restored target kernel in hibernation_snapshot().
476  */
477 int hibernation_restore(int platform_mode)
478 {
479 	int error;
480 
481 	pm_prepare_console();
482 	suspend_console();
483 	pm_restrict_gfp_mask();
484 	error = dpm_suspend_start(PMSG_QUIESCE);
485 	if (!error) {
486 		error = resume_target_kernel(platform_mode);
487 		dpm_resume_end(PMSG_RECOVER);
488 	}
489 	pm_restore_gfp_mask();
490 	resume_console();
491 	pm_restore_console();
492 	return error;
493 }
494 
495 /**
496  * hibernation_platform_enter - Power off the system using the platform driver.
497  */
498 int hibernation_platform_enter(void)
499 {
500 	int error;
501 
502 	if (!hibernation_ops)
503 		return -ENOSYS;
504 
505 	/*
506 	 * We have cancelled the power transition by running
507 	 * hibernation_ops->finish() before saving the image, so we should let
508 	 * the firmware know that we're going to enter the sleep state after all
509 	 */
510 	error = hibernation_ops->begin();
511 	if (error)
512 		goto Close;
513 
514 	entering_platform_hibernation = true;
515 	suspend_console();
516 	error = dpm_suspend_start(PMSG_HIBERNATE);
517 	if (error) {
518 		if (hibernation_ops->recover)
519 			hibernation_ops->recover();
520 		goto Resume_devices;
521 	}
522 
523 	error = dpm_suspend_end(PMSG_HIBERNATE);
524 	if (error)
525 		goto Resume_devices;
526 
527 	error = hibernation_ops->prepare();
528 	if (error)
529 		goto Platform_finish;
530 
531 	error = disable_nonboot_cpus();
532 	if (error)
533 		goto Platform_finish;
534 
535 	local_irq_disable();
536 	syscore_suspend();
537 	if (pm_wakeup_pending()) {
538 		error = -EAGAIN;
539 		goto Power_up;
540 	}
541 
542 	hibernation_ops->enter();
543 	/* We should never get here */
544 	while (1);
545 
546  Power_up:
547 	syscore_resume();
548 	local_irq_enable();
549 	enable_nonboot_cpus();
550 
551  Platform_finish:
552 	hibernation_ops->finish();
553 
554 	dpm_resume_start(PMSG_RESTORE);
555 
556  Resume_devices:
557 	entering_platform_hibernation = false;
558 	dpm_resume_end(PMSG_RESTORE);
559 	resume_console();
560 
561  Close:
562 	hibernation_ops->end();
563 
564 	return error;
565 }
566 
567 /**
568  * power_down - Shut the machine down for hibernation.
569  *
570  * Use the platform driver, if configured, to put the system into the sleep
571  * state corresponding to hibernation, or try to power it off or reboot,
572  * depending on the value of hibernation_mode.
573  */
574 static void power_down(void)
575 {
576 	switch (hibernation_mode) {
577 	case HIBERNATION_REBOOT:
578 		kernel_restart(NULL);
579 		break;
580 	case HIBERNATION_PLATFORM:
581 		hibernation_platform_enter();
582 	case HIBERNATION_SHUTDOWN:
583 		kernel_power_off();
584 		break;
585 	}
586 	kernel_halt();
587 	/*
588 	 * Valid image is on the disk, if we continue we risk serious data
589 	 * corruption after resume.
590 	 */
591 	printk(KERN_CRIT "PM: Please power down manually\n");
592 	while(1);
593 }
594 
595 /**
596  * hibernate - Carry out system hibernation, including saving the image.
597  */
598 int hibernate(void)
599 {
600 	int error;
601 
602 	lock_system_sleep();
603 	/* The snapshot device should not be opened while we're running */
604 	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
605 		error = -EBUSY;
606 		goto Unlock;
607 	}
608 
609 	pm_prepare_console();
610 	error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
611 	if (error)
612 		goto Exit;
613 
614 	error = usermodehelper_disable();
615 	if (error)
616 		goto Exit;
617 
618 	/* Allocate memory management structures */
619 	error = create_basic_memory_bitmaps();
620 	if (error)
621 		goto Enable_umh;
622 
623 	printk(KERN_INFO "PM: Syncing filesystems ... ");
624 	sys_sync();
625 	printk("done.\n");
626 
627 	error = freeze_processes();
628 	if (error)
629 		goto Free_bitmaps;
630 
631 	error = hibernation_snapshot(hibernation_mode == HIBERNATION_PLATFORM);
632 	if (error || freezer_test_done)
633 		goto Thaw;
634 
635 	if (in_suspend) {
636 		unsigned int flags = 0;
637 
638 		if (hibernation_mode == HIBERNATION_PLATFORM)
639 			flags |= SF_PLATFORM_MODE;
640 		if (nocompress)
641 			flags |= SF_NOCOMPRESS_MODE;
642 		else
643 		        flags |= SF_CRC32_MODE;
644 
645 		pr_debug("PM: writing image.\n");
646 		error = swsusp_write(flags);
647 		swsusp_free();
648 		if (!error)
649 			power_down();
650 		in_suspend = 0;
651 		pm_restore_gfp_mask();
652 	} else {
653 		pr_debug("PM: Image restored successfully.\n");
654 	}
655 
656  Thaw:
657 	thaw_processes();
658 
659 	/* Don't bother checking whether freezer_test_done is true */
660 	freezer_test_done = false;
661 
662  Free_bitmaps:
663 	free_basic_memory_bitmaps();
664  Enable_umh:
665 	usermodehelper_enable();
666  Exit:
667 	pm_notifier_call_chain(PM_POST_HIBERNATION);
668 	pm_restore_console();
669 	atomic_inc(&snapshot_device_available);
670  Unlock:
671 	unlock_system_sleep();
672 	return error;
673 }
674 
675 
676 /**
677  * software_resume - Resume from a saved hibernation image.
678  *
679  * This routine is called as a late initcall, when all devices have been
680  * discovered and initialized already.
681  *
682  * The image reading code is called to see if there is a hibernation image
683  * available for reading.  If that is the case, devices are quiesced and the
684  * contents of memory is restored from the saved image.
685  *
686  * If this is successful, control reappears in the restored target kernel in
687  * hibernation_snaphot() which returns to hibernate().  Otherwise, the routine
688  * attempts to recover gracefully and make the kernel return to the normal mode
689  * of operation.
690  */
691 static int software_resume(void)
692 {
693 	int error;
694 	unsigned int flags;
695 
696 	/*
697 	 * If the user said "noresume".. bail out early.
698 	 */
699 	if (noresume)
700 		return 0;
701 
702 	/*
703 	 * name_to_dev_t() below takes a sysfs buffer mutex when sysfs
704 	 * is configured into the kernel. Since the regular hibernate
705 	 * trigger path is via sysfs which takes a buffer mutex before
706 	 * calling hibernate functions (which take pm_mutex) this can
707 	 * cause lockdep to complain about a possible ABBA deadlock
708 	 * which cannot happen since we're in the boot code here and
709 	 * sysfs can't be invoked yet. Therefore, we use a subclass
710 	 * here to avoid lockdep complaining.
711 	 */
712 	mutex_lock_nested(&pm_mutex, SINGLE_DEPTH_NESTING);
713 
714 	if (swsusp_resume_device)
715 		goto Check_image;
716 
717 	if (!strlen(resume_file)) {
718 		error = -ENOENT;
719 		goto Unlock;
720 	}
721 
722 	pr_debug("PM: Checking hibernation image partition %s\n", resume_file);
723 
724 	if (resume_delay) {
725 		printk(KERN_INFO "Waiting %dsec before reading resume device...\n",
726 			resume_delay);
727 		ssleep(resume_delay);
728 	}
729 
730 	/* Check if the device is there */
731 	swsusp_resume_device = name_to_dev_t(resume_file);
732 	if (!swsusp_resume_device) {
733 		/*
734 		 * Some device discovery might still be in progress; we need
735 		 * to wait for this to finish.
736 		 */
737 		wait_for_device_probe();
738 
739 		if (resume_wait) {
740 			while ((swsusp_resume_device = name_to_dev_t(resume_file)) == 0)
741 				msleep(10);
742 			async_synchronize_full();
743 		}
744 
745 		/*
746 		 * We can't depend on SCSI devices being available after loading
747 		 * one of their modules until scsi_complete_async_scans() is
748 		 * called and the resume device usually is a SCSI one.
749 		 */
750 		scsi_complete_async_scans();
751 
752 		swsusp_resume_device = name_to_dev_t(resume_file);
753 		if (!swsusp_resume_device) {
754 			error = -ENODEV;
755 			goto Unlock;
756 		}
757 	}
758 
759  Check_image:
760 	pr_debug("PM: Hibernation image partition %d:%d present\n",
761 		MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
762 
763 	pr_debug("PM: Looking for hibernation image.\n");
764 	error = swsusp_check();
765 	if (error)
766 		goto Unlock;
767 
768 	/* The snapshot device should not be opened while we're running */
769 	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
770 		error = -EBUSY;
771 		swsusp_close(FMODE_READ);
772 		goto Unlock;
773 	}
774 
775 	pm_prepare_console();
776 	error = pm_notifier_call_chain(PM_RESTORE_PREPARE);
777 	if (error)
778 		goto close_finish;
779 
780 	error = usermodehelper_disable();
781 	if (error)
782 		goto close_finish;
783 
784 	error = create_basic_memory_bitmaps();
785 	if (error) {
786 		usermodehelper_enable();
787 		goto close_finish;
788 	}
789 
790 	pr_debug("PM: Preparing processes for restore.\n");
791 	error = freeze_processes();
792 	if (error) {
793 		swsusp_close(FMODE_READ);
794 		goto Done;
795 	}
796 
797 	pr_debug("PM: Loading hibernation image.\n");
798 
799 	error = swsusp_read(&flags);
800 	swsusp_close(FMODE_READ);
801 	if (!error)
802 		hibernation_restore(flags & SF_PLATFORM_MODE);
803 
804 	printk(KERN_ERR "PM: Failed to load hibernation image, recovering.\n");
805 	swsusp_free();
806 	thaw_processes();
807  Done:
808 	free_basic_memory_bitmaps();
809 	usermodehelper_enable();
810  Finish:
811 	pm_notifier_call_chain(PM_POST_RESTORE);
812 	pm_restore_console();
813 	atomic_inc(&snapshot_device_available);
814 	/* For success case, the suspend path will release the lock */
815  Unlock:
816 	mutex_unlock(&pm_mutex);
817 	pr_debug("PM: Hibernation image not present or could not be loaded.\n");
818 	return error;
819 close_finish:
820 	swsusp_close(FMODE_READ);
821 	goto Finish;
822 }
823 
824 late_initcall(software_resume);
825 
826 
827 static const char * const hibernation_modes[] = {
828 	[HIBERNATION_PLATFORM]	= "platform",
829 	[HIBERNATION_SHUTDOWN]	= "shutdown",
830 	[HIBERNATION_REBOOT]	= "reboot",
831 };
832 
833 /*
834  * /sys/power/disk - Control hibernation mode.
835  *
836  * Hibernation can be handled in several ways.  There are a few different ways
837  * to put the system into the sleep state: using the platform driver (e.g. ACPI
838  * or other hibernation_ops), powering it off or rebooting it (for testing
839  * mostly).
840  *
841  * The sysfs file /sys/power/disk provides an interface for selecting the
842  * hibernation mode to use.  Reading from this file causes the available modes
843  * to be printed.  There are 3 modes that can be supported:
844  *
845  *	'platform'
846  *	'shutdown'
847  *	'reboot'
848  *
849  * If a platform hibernation driver is in use, 'platform' will be supported
850  * and will be used by default.  Otherwise, 'shutdown' will be used by default.
851  * The selected option (i.e. the one corresponding to the current value of
852  * hibernation_mode) is enclosed by a square bracket.
853  *
854  * To select a given hibernation mode it is necessary to write the mode's
855  * string representation (as returned by reading from /sys/power/disk) back
856  * into /sys/power/disk.
857  */
858 
859 static ssize_t disk_show(struct kobject *kobj, struct kobj_attribute *attr,
860 			 char *buf)
861 {
862 	int i;
863 	char *start = buf;
864 
865 	for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
866 		if (!hibernation_modes[i])
867 			continue;
868 		switch (i) {
869 		case HIBERNATION_SHUTDOWN:
870 		case HIBERNATION_REBOOT:
871 			break;
872 		case HIBERNATION_PLATFORM:
873 			if (hibernation_ops)
874 				break;
875 			/* not a valid mode, continue with loop */
876 			continue;
877 		}
878 		if (i == hibernation_mode)
879 			buf += sprintf(buf, "[%s] ", hibernation_modes[i]);
880 		else
881 			buf += sprintf(buf, "%s ", hibernation_modes[i]);
882 	}
883 	buf += sprintf(buf, "\n");
884 	return buf-start;
885 }
886 
887 static ssize_t disk_store(struct kobject *kobj, struct kobj_attribute *attr,
888 			  const char *buf, size_t n)
889 {
890 	int error = 0;
891 	int i;
892 	int len;
893 	char *p;
894 	int mode = HIBERNATION_INVALID;
895 
896 	p = memchr(buf, '\n', n);
897 	len = p ? p - buf : n;
898 
899 	lock_system_sleep();
900 	for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
901 		if (len == strlen(hibernation_modes[i])
902 		    && !strncmp(buf, hibernation_modes[i], len)) {
903 			mode = i;
904 			break;
905 		}
906 	}
907 	if (mode != HIBERNATION_INVALID) {
908 		switch (mode) {
909 		case HIBERNATION_SHUTDOWN:
910 		case HIBERNATION_REBOOT:
911 			hibernation_mode = mode;
912 			break;
913 		case HIBERNATION_PLATFORM:
914 			if (hibernation_ops)
915 				hibernation_mode = mode;
916 			else
917 				error = -EINVAL;
918 		}
919 	} else
920 		error = -EINVAL;
921 
922 	if (!error)
923 		pr_debug("PM: Hibernation mode set to '%s'\n",
924 			 hibernation_modes[mode]);
925 	unlock_system_sleep();
926 	return error ? error : n;
927 }
928 
929 power_attr(disk);
930 
931 static ssize_t resume_show(struct kobject *kobj, struct kobj_attribute *attr,
932 			   char *buf)
933 {
934 	return sprintf(buf,"%d:%d\n", MAJOR(swsusp_resume_device),
935 		       MINOR(swsusp_resume_device));
936 }
937 
938 static ssize_t resume_store(struct kobject *kobj, struct kobj_attribute *attr,
939 			    const char *buf, size_t n)
940 {
941 	unsigned int maj, min;
942 	dev_t res;
943 	int ret = -EINVAL;
944 
945 	if (sscanf(buf, "%u:%u", &maj, &min) != 2)
946 		goto out;
947 
948 	res = MKDEV(maj,min);
949 	if (maj != MAJOR(res) || min != MINOR(res))
950 		goto out;
951 
952 	lock_system_sleep();
953 	swsusp_resume_device = res;
954 	unlock_system_sleep();
955 	printk(KERN_INFO "PM: Starting manual resume from disk\n");
956 	noresume = 0;
957 	software_resume();
958 	ret = n;
959  out:
960 	return ret;
961 }
962 
963 power_attr(resume);
964 
965 static ssize_t image_size_show(struct kobject *kobj, struct kobj_attribute *attr,
966 			       char *buf)
967 {
968 	return sprintf(buf, "%lu\n", image_size);
969 }
970 
971 static ssize_t image_size_store(struct kobject *kobj, struct kobj_attribute *attr,
972 				const char *buf, size_t n)
973 {
974 	unsigned long size;
975 
976 	if (sscanf(buf, "%lu", &size) == 1) {
977 		image_size = size;
978 		return n;
979 	}
980 
981 	return -EINVAL;
982 }
983 
984 power_attr(image_size);
985 
986 static ssize_t reserved_size_show(struct kobject *kobj,
987 				  struct kobj_attribute *attr, char *buf)
988 {
989 	return sprintf(buf, "%lu\n", reserved_size);
990 }
991 
992 static ssize_t reserved_size_store(struct kobject *kobj,
993 				   struct kobj_attribute *attr,
994 				   const char *buf, size_t n)
995 {
996 	unsigned long size;
997 
998 	if (sscanf(buf, "%lu", &size) == 1) {
999 		reserved_size = size;
1000 		return n;
1001 	}
1002 
1003 	return -EINVAL;
1004 }
1005 
1006 power_attr(reserved_size);
1007 
1008 static struct attribute * g[] = {
1009 	&disk_attr.attr,
1010 	&resume_attr.attr,
1011 	&image_size_attr.attr,
1012 	&reserved_size_attr.attr,
1013 	NULL,
1014 };
1015 
1016 
1017 static struct attribute_group attr_group = {
1018 	.attrs = g,
1019 };
1020 
1021 
1022 static int __init pm_disk_init(void)
1023 {
1024 	return sysfs_create_group(power_kobj, &attr_group);
1025 }
1026 
1027 core_initcall(pm_disk_init);
1028 
1029 
1030 static int __init resume_setup(char *str)
1031 {
1032 	if (noresume)
1033 		return 1;
1034 
1035 	strncpy( resume_file, str, 255 );
1036 	return 1;
1037 }
1038 
1039 static int __init resume_offset_setup(char *str)
1040 {
1041 	unsigned long long offset;
1042 
1043 	if (noresume)
1044 		return 1;
1045 
1046 	if (sscanf(str, "%llu", &offset) == 1)
1047 		swsusp_resume_block = offset;
1048 
1049 	return 1;
1050 }
1051 
1052 static int __init hibernate_setup(char *str)
1053 {
1054 	if (!strncmp(str, "noresume", 8))
1055 		noresume = 1;
1056 	else if (!strncmp(str, "nocompress", 10))
1057 		nocompress = 1;
1058 	return 1;
1059 }
1060 
1061 static int __init noresume_setup(char *str)
1062 {
1063 	noresume = 1;
1064 	return 1;
1065 }
1066 
1067 static int __init resumewait_setup(char *str)
1068 {
1069 	resume_wait = 1;
1070 	return 1;
1071 }
1072 
1073 static int __init resumedelay_setup(char *str)
1074 {
1075 	resume_delay = simple_strtoul(str, NULL, 0);
1076 	return 1;
1077 }
1078 
1079 __setup("noresume", noresume_setup);
1080 __setup("resume_offset=", resume_offset_setup);
1081 __setup("resume=", resume_setup);
1082 __setup("hibernate=", hibernate_setup);
1083 __setup("resumewait", resumewait_setup);
1084 __setup("resumedelay=", resumedelay_setup);
1085