1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * kernel/power/hibernate.c - Hibernation (a.k.a suspend-to-disk) support.
4 *
5 * Copyright (c) 2003 Patrick Mochel
6 * Copyright (c) 2003 Open Source Development Lab
7 * Copyright (c) 2004 Pavel Machek <pavel@ucw.cz>
8 * Copyright (c) 2009 Rafael J. Wysocki, Novell Inc.
9 * Copyright (C) 2012 Bojan Smojver <bojan@rexursive.com>
10 */
11
12#define pr_fmt(fmt) "PM: hibernation: " fmt
13
14#include <linux/blkdev.h>
15#include <linux/export.h>
16#include <linux/suspend.h>
17#include <linux/reboot.h>
18#include <linux/string.h>
19#include <linux/device.h>
20#include <linux/async.h>
21#include <linux/delay.h>
22#include <linux/fs.h>
23#include <linux/mount.h>
24#include <linux/pm.h>
25#include <linux/nmi.h>
26#include <linux/console.h>
27#include <linux/cpu.h>
28#include <linux/freezer.h>
29#include <linux/gfp.h>
30#include <linux/syscore_ops.h>
31#include <linux/ctype.h>
32#include <linux/ktime.h>
33#include <linux/security.h>
34#include <linux/secretmem.h>
35#include <trace/events/power.h>
36
37#include "power.h"
38
39
40static int nocompress;
41static int noresume;
42static int nohibernate;
43static int resume_wait;
44static unsigned int resume_delay;
45static char resume_file[256] = CONFIG_PM_STD_PARTITION;
46dev_t swsusp_resume_device;
47sector_t swsusp_resume_block;
48__visible int in_suspend __nosavedata;
49
50enum {
51 HIBERNATION_INVALID,
52 HIBERNATION_PLATFORM,
53 HIBERNATION_SHUTDOWN,
54 HIBERNATION_REBOOT,
55#ifdef CONFIG_SUSPEND
56 HIBERNATION_SUSPEND,
57#endif
58 HIBERNATION_TEST_RESUME,
59 /* keep last */
60 __HIBERNATION_AFTER_LAST
61};
62#define HIBERNATION_MAX (__HIBERNATION_AFTER_LAST-1)
63#define HIBERNATION_FIRST (HIBERNATION_INVALID + 1)
64
65static int hibernation_mode = HIBERNATION_SHUTDOWN;
66
67bool freezer_test_done;
68
69static const struct platform_hibernation_ops *hibernation_ops;
70
71static atomic_t hibernate_atomic = ATOMIC_INIT(1);
72
73bool hibernate_acquire(void)
74{
75 return atomic_add_unless(v: &hibernate_atomic, a: -1, u: 0);
76}
77
78void hibernate_release(void)
79{
80 atomic_inc(v: &hibernate_atomic);
81}
82
83bool hibernation_available(void)
84{
85 return nohibernate == 0 &&
86 !security_locked_down(what: LOCKDOWN_HIBERNATION) &&
87 !secretmem_active() && !cxl_mem_active();
88}
89
90/**
91 * hibernation_set_ops - Set the global hibernate operations.
92 * @ops: Hibernation operations to use in subsequent hibernation transitions.
93 */
94void hibernation_set_ops(const struct platform_hibernation_ops *ops)
95{
96 unsigned int sleep_flags;
97
98 if (ops && !(ops->begin && ops->end && ops->pre_snapshot
99 && ops->prepare && ops->finish && ops->enter && ops->pre_restore
100 && ops->restore_cleanup && ops->leave)) {
101 WARN_ON(1);
102 return;
103 }
104
105 sleep_flags = lock_system_sleep();
106
107 hibernation_ops = ops;
108 if (ops)
109 hibernation_mode = HIBERNATION_PLATFORM;
110 else if (hibernation_mode == HIBERNATION_PLATFORM)
111 hibernation_mode = HIBERNATION_SHUTDOWN;
112
113 unlock_system_sleep(sleep_flags);
114}
115EXPORT_SYMBOL_GPL(hibernation_set_ops);
116
117static bool entering_platform_hibernation;
118
119bool system_entering_hibernation(void)
120{
121 return entering_platform_hibernation;
122}
123EXPORT_SYMBOL(system_entering_hibernation);
124
125#ifdef CONFIG_PM_DEBUG
126static void hibernation_debug_sleep(void)
127{
128 pr_info("debug: Waiting for 5 seconds.\n");
129 mdelay(5000);
130}
131
132static int hibernation_test(int level)
133{
134 if (pm_test_level == level) {
135 hibernation_debug_sleep();
136 return 1;
137 }
138 return 0;
139}
140#else /* !CONFIG_PM_DEBUG */
141static int hibernation_test(int level) { return 0; }
142#endif /* !CONFIG_PM_DEBUG */
143
144/**
145 * platform_begin - Call platform to start hibernation.
146 * @platform_mode: Whether or not to use the platform driver.
147 */
148static int platform_begin(int platform_mode)
149{
150 return (platform_mode && hibernation_ops) ?
151 hibernation_ops->begin(PMSG_FREEZE) : 0;
152}
153
154/**
155 * platform_end - Call platform to finish transition to the working state.
156 * @platform_mode: Whether or not to use the platform driver.
157 */
158static void platform_end(int platform_mode)
159{
160 if (platform_mode && hibernation_ops)
161 hibernation_ops->end();
162}
163
164/**
165 * platform_pre_snapshot - Call platform to prepare the machine for hibernation.
166 * @platform_mode: Whether or not to use the platform driver.
167 *
168 * Use the platform driver to prepare the system for creating a hibernate image,
169 * if so configured, and return an error code if that fails.
170 */
171
172static int platform_pre_snapshot(int platform_mode)
173{
174 return (platform_mode && hibernation_ops) ?
175 hibernation_ops->pre_snapshot() : 0;
176}
177
178/**
179 * platform_leave - Call platform to prepare a transition to the working state.
180 * @platform_mode: Whether or not to use the platform driver.
181 *
182 * Use the platform driver prepare to prepare the machine for switching to the
183 * normal mode of operation.
184 *
185 * This routine is called on one CPU with interrupts disabled.
186 */
187static void platform_leave(int platform_mode)
188{
189 if (platform_mode && hibernation_ops)
190 hibernation_ops->leave();
191}
192
193/**
194 * platform_finish - Call platform to switch the system to the working state.
195 * @platform_mode: Whether or not to use the platform driver.
196 *
197 * Use the platform driver to switch the machine to the normal mode of
198 * operation.
199 *
200 * This routine must be called after platform_prepare().
201 */
202static void platform_finish(int platform_mode)
203{
204 if (platform_mode && hibernation_ops)
205 hibernation_ops->finish();
206}
207
208/**
209 * platform_pre_restore - Prepare for hibernate image restoration.
210 * @platform_mode: Whether or not to use the platform driver.
211 *
212 * Use the platform driver to prepare the system for resume from a hibernation
213 * image.
214 *
215 * If the restore fails after this function has been called,
216 * platform_restore_cleanup() must be called.
217 */
218static int platform_pre_restore(int platform_mode)
219{
220 return (platform_mode && hibernation_ops) ?
221 hibernation_ops->pre_restore() : 0;
222}
223
224/**
225 * platform_restore_cleanup - Switch to the working state after failing restore.
226 * @platform_mode: Whether or not to use the platform driver.
227 *
228 * Use the platform driver to switch the system to the normal mode of operation
229 * after a failing restore.
230 *
231 * If platform_pre_restore() has been called before the failing restore, this
232 * function must be called too, regardless of the result of
233 * platform_pre_restore().
234 */
235static void platform_restore_cleanup(int platform_mode)
236{
237 if (platform_mode && hibernation_ops)
238 hibernation_ops->restore_cleanup();
239}
240
241/**
242 * platform_recover - Recover from a failure to suspend devices.
243 * @platform_mode: Whether or not to use the platform driver.
244 */
245static void platform_recover(int platform_mode)
246{
247 if (platform_mode && hibernation_ops && hibernation_ops->recover)
248 hibernation_ops->recover();
249}
250
251/**
252 * swsusp_show_speed - Print time elapsed between two events during hibernation.
253 * @start: Starting event.
254 * @stop: Final event.
255 * @nr_pages: Number of memory pages processed between @start and @stop.
256 * @msg: Additional diagnostic message to print.
257 */
258void swsusp_show_speed(ktime_t start, ktime_t stop,
259 unsigned nr_pages, char *msg)
260{
261 ktime_t diff;
262 u64 elapsed_centisecs64;
263 unsigned int centisecs;
264 unsigned int k;
265 unsigned int kps;
266
267 diff = ktime_sub(stop, start);
268 elapsed_centisecs64 = ktime_divns(kt: diff, div: 10*NSEC_PER_MSEC);
269 centisecs = elapsed_centisecs64;
270 if (centisecs == 0)
271 centisecs = 1; /* avoid div-by-zero */
272 k = nr_pages * (PAGE_SIZE / 1024);
273 kps = (k * 100) / centisecs;
274 pr_info("%s %u kbytes in %u.%02u seconds (%u.%02u MB/s)\n",
275 msg, k, centisecs / 100, centisecs % 100, kps / 1000,
276 (kps % 1000) / 10);
277}
278
279__weak int arch_resume_nosmt(void)
280{
281 return 0;
282}
283
284/**
285 * create_image - Create a hibernation image.
286 * @platform_mode: Whether or not to use the platform driver.
287 *
288 * Execute device drivers' "late" and "noirq" freeze callbacks, create a
289 * hibernation image and run the drivers' "noirq" and "early" thaw callbacks.
290 *
291 * Control reappears in this routine after the subsequent restore.
292 */
293static int create_image(int platform_mode)
294{
295 int error;
296
297 error = dpm_suspend_end(PMSG_FREEZE);
298 if (error) {
299 pr_err("Some devices failed to power down, aborting\n");
300 return error;
301 }
302
303 error = platform_pre_snapshot(platform_mode);
304 if (error || hibernation_test(level: TEST_PLATFORM))
305 goto Platform_finish;
306
307 error = pm_sleep_disable_secondary_cpus();
308 if (error || hibernation_test(level: TEST_CPUS))
309 goto Enable_cpus;
310
311 local_irq_disable();
312
313 system_state = SYSTEM_SUSPEND;
314
315 error = syscore_suspend();
316 if (error) {
317 pr_err("Some system devices failed to power down, aborting\n");
318 goto Enable_irqs;
319 }
320
321 if (hibernation_test(level: TEST_CORE) || pm_wakeup_pending())
322 goto Power_up;
323
324 in_suspend = 1;
325 save_processor_state();
326 trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, start: true);
327 error = swsusp_arch_suspend();
328 /* Restore control flow magically appears here */
329 restore_processor_state();
330 trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, start: false);
331 if (error)
332 pr_err("Error %d creating image\n", error);
333
334 if (!in_suspend) {
335 events_check_enabled = false;
336 clear_or_poison_free_pages();
337 }
338
339 platform_leave(platform_mode);
340
341 Power_up:
342 syscore_resume();
343
344 Enable_irqs:
345 system_state = SYSTEM_RUNNING;
346 local_irq_enable();
347
348 Enable_cpus:
349 pm_sleep_enable_secondary_cpus();
350
351 /* Allow architectures to do nosmt-specific post-resume dances */
352 if (!in_suspend)
353 error = arch_resume_nosmt();
354
355 Platform_finish:
356 platform_finish(platform_mode);
357
358 dpm_resume_start(state: in_suspend ?
359 (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
360
361 return error;
362}
363
364/**
365 * hibernation_snapshot - Quiesce devices and create a hibernation image.
366 * @platform_mode: If set, use platform driver to prepare for the transition.
367 *
368 * This routine must be called with system_transition_mutex held.
369 */
370int hibernation_snapshot(int platform_mode)
371{
372 pm_message_t msg;
373 int error;
374
375 pm_suspend_clear_flags();
376 error = platform_begin(platform_mode);
377 if (error)
378 goto Close;
379
380 /* Preallocate image memory before shutting down devices. */
381 error = hibernate_preallocate_memory();
382 if (error)
383 goto Close;
384
385 error = freeze_kernel_threads();
386 if (error)
387 goto Cleanup;
388
389 if (hibernation_test(level: TEST_FREEZER)) {
390
391 /*
392 * Indicate to the caller that we are returning due to a
393 * successful freezer test.
394 */
395 freezer_test_done = true;
396 goto Thaw;
397 }
398
399 error = dpm_prepare(PMSG_FREEZE);
400 if (error) {
401 dpm_complete(PMSG_RECOVER);
402 goto Thaw;
403 }
404
405 suspend_console();
406 pm_restrict_gfp_mask();
407
408 error = dpm_suspend(PMSG_FREEZE);
409
410 if (error || hibernation_test(level: TEST_DEVICES))
411 platform_recover(platform_mode);
412 else
413 error = create_image(platform_mode);
414
415 /*
416 * In the case that we call create_image() above, the control
417 * returns here (1) after the image has been created or the
418 * image creation has failed and (2) after a successful restore.
419 */
420
421 /* We may need to release the preallocated image pages here. */
422 if (error || !in_suspend)
423 swsusp_free();
424
425 msg = in_suspend ? (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE;
426 dpm_resume(state: msg);
427
428 if (error || !in_suspend)
429 pm_restore_gfp_mask();
430
431 resume_console();
432 dpm_complete(state: msg);
433
434 Close:
435 platform_end(platform_mode);
436 return error;
437
438 Thaw:
439 thaw_kernel_threads();
440 Cleanup:
441 swsusp_free();
442 goto Close;
443}
444
445int __weak hibernate_resume_nonboot_cpu_disable(void)
446{
447 return suspend_disable_secondary_cpus();
448}
449
450/**
451 * resume_target_kernel - Restore system state from a hibernation image.
452 * @platform_mode: Whether or not to use the platform driver.
453 *
454 * Execute device drivers' "noirq" and "late" freeze callbacks, restore the
455 * contents of highmem that have not been restored yet from the image and run
456 * the low-level code that will restore the remaining contents of memory and
457 * switch to the just restored target kernel.
458 */
459static int resume_target_kernel(bool platform_mode)
460{
461 int error;
462
463 error = dpm_suspend_end(PMSG_QUIESCE);
464 if (error) {
465 pr_err("Some devices failed to power down, aborting resume\n");
466 return error;
467 }
468
469 error = platform_pre_restore(platform_mode);
470 if (error)
471 goto Cleanup;
472
473 cpuidle_pause();
474
475 error = hibernate_resume_nonboot_cpu_disable();
476 if (error)
477 goto Enable_cpus;
478
479 local_irq_disable();
480 system_state = SYSTEM_SUSPEND;
481
482 error = syscore_suspend();
483 if (error)
484 goto Enable_irqs;
485
486 save_processor_state();
487 error = restore_highmem();
488 if (!error) {
489 error = swsusp_arch_resume();
490 /*
491 * The code below is only ever reached in case of a failure.
492 * Otherwise, execution continues at the place where
493 * swsusp_arch_suspend() was called.
494 */
495 BUG_ON(!error);
496 /*
497 * This call to restore_highmem() reverts the changes made by
498 * the previous one.
499 */
500 restore_highmem();
501 }
502 /*
503 * The only reason why swsusp_arch_resume() can fail is memory being
504 * very tight, so we have to free it as soon as we can to avoid
505 * subsequent failures.
506 */
507 swsusp_free();
508 restore_processor_state();
509 touch_softlockup_watchdog();
510
511 syscore_resume();
512
513 Enable_irqs:
514 system_state = SYSTEM_RUNNING;
515 local_irq_enable();
516
517 Enable_cpus:
518 pm_sleep_enable_secondary_cpus();
519
520 Cleanup:
521 platform_restore_cleanup(platform_mode);
522
523 dpm_resume_start(PMSG_RECOVER);
524
525 return error;
526}
527
528/**
529 * hibernation_restore - Quiesce devices and restore from a hibernation image.
530 * @platform_mode: If set, use platform driver to prepare for the transition.
531 *
532 * This routine must be called with system_transition_mutex held. If it is
533 * successful, control reappears in the restored target kernel in
534 * hibernation_snapshot().
535 */
536int hibernation_restore(int platform_mode)
537{
538 int error;
539
540 pm_prepare_console();
541 suspend_console();
542 pm_restrict_gfp_mask();
543 error = dpm_suspend_start(PMSG_QUIESCE);
544 if (!error) {
545 error = resume_target_kernel(platform_mode);
546 /*
547 * The above should either succeed and jump to the new kernel,
548 * or return with an error. Otherwise things are just
549 * undefined, so let's be paranoid.
550 */
551 BUG_ON(!error);
552 }
553 dpm_resume_end(PMSG_RECOVER);
554 pm_restore_gfp_mask();
555 resume_console();
556 pm_restore_console();
557 return error;
558}
559
560/**
561 * hibernation_platform_enter - Power off the system using the platform driver.
562 */
563int hibernation_platform_enter(void)
564{
565 int error;
566
567 if (!hibernation_ops)
568 return -ENOSYS;
569
570 /*
571 * We have cancelled the power transition by running
572 * hibernation_ops->finish() before saving the image, so we should let
573 * the firmware know that we're going to enter the sleep state after all
574 */
575 error = hibernation_ops->begin(PMSG_HIBERNATE);
576 if (error)
577 goto Close;
578
579 entering_platform_hibernation = true;
580 suspend_console();
581 error = dpm_suspend_start(PMSG_HIBERNATE);
582 if (error) {
583 if (hibernation_ops->recover)
584 hibernation_ops->recover();
585 goto Resume_devices;
586 }
587
588 error = dpm_suspend_end(PMSG_HIBERNATE);
589 if (error)
590 goto Resume_devices;
591
592 error = hibernation_ops->prepare();
593 if (error)
594 goto Platform_finish;
595
596 error = pm_sleep_disable_secondary_cpus();
597 if (error)
598 goto Enable_cpus;
599
600 local_irq_disable();
601 system_state = SYSTEM_SUSPEND;
602 syscore_suspend();
603 if (pm_wakeup_pending()) {
604 error = -EAGAIN;
605 goto Power_up;
606 }
607
608 hibernation_ops->enter();
609 /* We should never get here */
610 while (1);
611
612 Power_up:
613 syscore_resume();
614 system_state = SYSTEM_RUNNING;
615 local_irq_enable();
616
617 Enable_cpus:
618 pm_sleep_enable_secondary_cpus();
619
620 Platform_finish:
621 hibernation_ops->finish();
622
623 dpm_resume_start(PMSG_RESTORE);
624
625 Resume_devices:
626 entering_platform_hibernation = false;
627 dpm_resume_end(PMSG_RESTORE);
628 resume_console();
629
630 Close:
631 hibernation_ops->end();
632
633 return error;
634}
635
636/**
637 * power_down - Shut the machine down for hibernation.
638 *
639 * Use the platform driver, if configured, to put the system into the sleep
640 * state corresponding to hibernation, or try to power it off or reboot,
641 * depending on the value of hibernation_mode.
642 */
643static void power_down(void)
644{
645#ifdef CONFIG_SUSPEND
646 int error;
647
648 if (hibernation_mode == HIBERNATION_SUSPEND) {
649 error = suspend_devices_and_enter(state: mem_sleep_current);
650 if (error) {
651 hibernation_mode = hibernation_ops ?
652 HIBERNATION_PLATFORM :
653 HIBERNATION_SHUTDOWN;
654 } else {
655 /* Restore swap signature. */
656 error = swsusp_unmark();
657 if (error)
658 pr_err("Swap will be unusable! Try swapon -a.\n");
659
660 return;
661 }
662 }
663#endif
664
665 switch (hibernation_mode) {
666 case HIBERNATION_REBOOT:
667 kernel_restart(NULL);
668 break;
669 case HIBERNATION_PLATFORM:
670 hibernation_platform_enter();
671 fallthrough;
672 case HIBERNATION_SHUTDOWN:
673 if (kernel_can_power_off())
674 kernel_power_off();
675 break;
676 }
677 kernel_halt();
678 /*
679 * Valid image is on the disk, if we continue we risk serious data
680 * corruption after resume.
681 */
682 pr_crit("Power down manually\n");
683 while (1)
684 cpu_relax();
685}
686
687static int load_image_and_restore(void)
688{
689 int error;
690 unsigned int flags;
691
692 pm_pr_dbg("Loading hibernation image.\n");
693
694 lock_device_hotplug();
695 error = create_basic_memory_bitmaps();
696 if (error) {
697 swsusp_close();
698 goto Unlock;
699 }
700
701 error = swsusp_read(flags_p: &flags);
702 swsusp_close();
703 if (!error)
704 error = hibernation_restore(platform_mode: flags & SF_PLATFORM_MODE);
705
706 pr_err("Failed to load image, recovering.\n");
707 swsusp_free();
708 free_basic_memory_bitmaps();
709 Unlock:
710 unlock_device_hotplug();
711
712 return error;
713}
714
715/**
716 * hibernate - Carry out system hibernation, including saving the image.
717 */
718int hibernate(void)
719{
720 bool snapshot_test = false;
721 unsigned int sleep_flags;
722 int error;
723
724 if (!hibernation_available()) {
725 pm_pr_dbg("Hibernation not available.\n");
726 return -EPERM;
727 }
728
729 sleep_flags = lock_system_sleep();
730 /* The snapshot device should not be opened while we're running */
731 if (!hibernate_acquire()) {
732 error = -EBUSY;
733 goto Unlock;
734 }
735
736 pr_info("hibernation entry\n");
737 pm_prepare_console();
738 error = pm_notifier_call_chain_robust(PM_HIBERNATION_PREPARE, PM_POST_HIBERNATION);
739 if (error)
740 goto Restore;
741
742 ksys_sync_helper();
743
744 error = freeze_processes();
745 if (error)
746 goto Exit;
747
748 lock_device_hotplug();
749 /* Allocate memory management structures */
750 error = create_basic_memory_bitmaps();
751 if (error)
752 goto Thaw;
753
754 error = hibernation_snapshot(platform_mode: hibernation_mode == HIBERNATION_PLATFORM);
755 if (error || freezer_test_done)
756 goto Free_bitmaps;
757
758 if (in_suspend) {
759 unsigned int flags = 0;
760
761 if (hibernation_mode == HIBERNATION_PLATFORM)
762 flags |= SF_PLATFORM_MODE;
763 if (nocompress)
764 flags |= SF_NOCOMPRESS_MODE;
765 else
766 flags |= SF_CRC32_MODE;
767
768 pm_pr_dbg("Writing hibernation image.\n");
769 error = swsusp_write(flags);
770 swsusp_free();
771 if (!error) {
772 if (hibernation_mode == HIBERNATION_TEST_RESUME)
773 snapshot_test = true;
774 else
775 power_down();
776 }
777 in_suspend = 0;
778 pm_restore_gfp_mask();
779 } else {
780 pm_pr_dbg("Hibernation image restored successfully.\n");
781 }
782
783 Free_bitmaps:
784 free_basic_memory_bitmaps();
785 Thaw:
786 unlock_device_hotplug();
787 if (snapshot_test) {
788 pm_pr_dbg("Checking hibernation image\n");
789 error = swsusp_check(exclusive: false);
790 if (!error)
791 error = load_image_and_restore();
792 }
793 thaw_processes();
794
795 /* Don't bother checking whether freezer_test_done is true */
796 freezer_test_done = false;
797 Exit:
798 pm_notifier_call_chain(PM_POST_HIBERNATION);
799 Restore:
800 pm_restore_console();
801 hibernate_release();
802 Unlock:
803 unlock_system_sleep(sleep_flags);
804 pr_info("hibernation exit\n");
805
806 return error;
807}
808
809/**
810 * hibernate_quiet_exec - Execute a function with all devices frozen.
811 * @func: Function to execute.
812 * @data: Data pointer to pass to @func.
813 *
814 * Return the @func return value or an error code if it cannot be executed.
815 */
816int hibernate_quiet_exec(int (*func)(void *data), void *data)
817{
818 unsigned int sleep_flags;
819 int error;
820
821 sleep_flags = lock_system_sleep();
822
823 if (!hibernate_acquire()) {
824 error = -EBUSY;
825 goto unlock;
826 }
827
828 pm_prepare_console();
829
830 error = pm_notifier_call_chain_robust(PM_HIBERNATION_PREPARE, PM_POST_HIBERNATION);
831 if (error)
832 goto restore;
833
834 error = freeze_processes();
835 if (error)
836 goto exit;
837
838 lock_device_hotplug();
839
840 pm_suspend_clear_flags();
841
842 error = platform_begin(platform_mode: true);
843 if (error)
844 goto thaw;
845
846 error = freeze_kernel_threads();
847 if (error)
848 goto thaw;
849
850 error = dpm_prepare(PMSG_FREEZE);
851 if (error)
852 goto dpm_complete;
853
854 suspend_console();
855
856 error = dpm_suspend(PMSG_FREEZE);
857 if (error)
858 goto dpm_resume;
859
860 error = dpm_suspend_end(PMSG_FREEZE);
861 if (error)
862 goto dpm_resume;
863
864 error = platform_pre_snapshot(platform_mode: true);
865 if (error)
866 goto skip;
867
868 error = func(data);
869
870skip:
871 platform_finish(platform_mode: true);
872
873 dpm_resume_start(PMSG_THAW);
874
875dpm_resume:
876 dpm_resume(PMSG_THAW);
877
878 resume_console();
879
880dpm_complete:
881 dpm_complete(PMSG_THAW);
882
883 thaw_kernel_threads();
884
885thaw:
886 platform_end(platform_mode: true);
887
888 unlock_device_hotplug();
889
890 thaw_processes();
891
892exit:
893 pm_notifier_call_chain(PM_POST_HIBERNATION);
894
895restore:
896 pm_restore_console();
897
898 hibernate_release();
899
900unlock:
901 unlock_system_sleep(sleep_flags);
902
903 return error;
904}
905EXPORT_SYMBOL_GPL(hibernate_quiet_exec);
906
907static int __init find_resume_device(void)
908{
909 if (!strlen(resume_file))
910 return -ENOENT;
911
912 pm_pr_dbg("Checking hibernation image partition %s\n", resume_file);
913
914 if (resume_delay) {
915 pr_info("Waiting %dsec before reading resume device ...\n",
916 resume_delay);
917 ssleep(seconds: resume_delay);
918 }
919
920 /* Check if the device is there */
921 if (!early_lookup_bdev(pathname: resume_file, dev: &swsusp_resume_device))
922 return 0;
923
924 /*
925 * Some device discovery might still be in progress; we need to wait for
926 * this to finish.
927 */
928 wait_for_device_probe();
929 if (resume_wait) {
930 while (early_lookup_bdev(pathname: resume_file, dev: &swsusp_resume_device))
931 msleep(msecs: 10);
932 async_synchronize_full();
933 }
934
935 return early_lookup_bdev(pathname: resume_file, dev: &swsusp_resume_device);
936}
937
938static int software_resume(void)
939{
940 int error;
941
942 pm_pr_dbg("Hibernation image partition %d:%d present\n",
943 MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
944
945 pm_pr_dbg("Looking for hibernation image.\n");
946
947 mutex_lock(&system_transition_mutex);
948 error = swsusp_check(exclusive: true);
949 if (error)
950 goto Unlock;
951
952 /* The snapshot device should not be opened while we're running */
953 if (!hibernate_acquire()) {
954 error = -EBUSY;
955 swsusp_close();
956 goto Unlock;
957 }
958
959 pr_info("resume from hibernation\n");
960 pm_prepare_console();
961 error = pm_notifier_call_chain_robust(PM_RESTORE_PREPARE, PM_POST_RESTORE);
962 if (error)
963 goto Restore;
964
965 pm_pr_dbg("Preparing processes for hibernation restore.\n");
966 error = freeze_processes();
967 if (error)
968 goto Close_Finish;
969
970 error = freeze_kernel_threads();
971 if (error) {
972 thaw_processes();
973 goto Close_Finish;
974 }
975
976 error = load_image_and_restore();
977 thaw_processes();
978 Finish:
979 pm_notifier_call_chain(PM_POST_RESTORE);
980 Restore:
981 pm_restore_console();
982 pr_info("resume failed (%d)\n", error);
983 hibernate_release();
984 /* For success case, the suspend path will release the lock */
985 Unlock:
986 mutex_unlock(lock: &system_transition_mutex);
987 pm_pr_dbg("Hibernation image not present or could not be loaded.\n");
988 return error;
989 Close_Finish:
990 swsusp_close();
991 goto Finish;
992}
993
994/**
995 * software_resume_initcall - Resume from a saved hibernation image.
996 *
997 * This routine is called as a late initcall, when all devices have been
998 * discovered and initialized already.
999 *
1000 * The image reading code is called to see if there is a hibernation image
1001 * available for reading. If that is the case, devices are quiesced and the
1002 * contents of memory is restored from the saved image.
1003 *
1004 * If this is successful, control reappears in the restored target kernel in
1005 * hibernation_snapshot() which returns to hibernate(). Otherwise, the routine
1006 * attempts to recover gracefully and make the kernel return to the normal mode
1007 * of operation.
1008 */
1009static int __init software_resume_initcall(void)
1010{
1011 /*
1012 * If the user said "noresume".. bail out early.
1013 */
1014 if (noresume || !hibernation_available())
1015 return 0;
1016
1017 if (!swsusp_resume_device) {
1018 int error = find_resume_device();
1019
1020 if (error)
1021 return error;
1022 }
1023
1024 return software_resume();
1025}
1026late_initcall_sync(software_resume_initcall);
1027
1028
1029static const char * const hibernation_modes[] = {
1030 [HIBERNATION_PLATFORM] = "platform",
1031 [HIBERNATION_SHUTDOWN] = "shutdown",
1032 [HIBERNATION_REBOOT] = "reboot",
1033#ifdef CONFIG_SUSPEND
1034 [HIBERNATION_SUSPEND] = "suspend",
1035#endif
1036 [HIBERNATION_TEST_RESUME] = "test_resume",
1037};
1038
1039/*
1040 * /sys/power/disk - Control hibernation mode.
1041 *
1042 * Hibernation can be handled in several ways. There are a few different ways
1043 * to put the system into the sleep state: using the platform driver (e.g. ACPI
1044 * or other hibernation_ops), powering it off or rebooting it (for testing
1045 * mostly).
1046 *
1047 * The sysfs file /sys/power/disk provides an interface for selecting the
1048 * hibernation mode to use. Reading from this file causes the available modes
1049 * to be printed. There are 3 modes that can be supported:
1050 *
1051 * 'platform'
1052 * 'shutdown'
1053 * 'reboot'
1054 *
1055 * If a platform hibernation driver is in use, 'platform' will be supported
1056 * and will be used by default. Otherwise, 'shutdown' will be used by default.
1057 * The selected option (i.e. the one corresponding to the current value of
1058 * hibernation_mode) is enclosed by a square bracket.
1059 *
1060 * To select a given hibernation mode it is necessary to write the mode's
1061 * string representation (as returned by reading from /sys/power/disk) back
1062 * into /sys/power/disk.
1063 */
1064
1065static ssize_t disk_show(struct kobject *kobj, struct kobj_attribute *attr,
1066 char *buf)
1067{
1068 int i;
1069 char *start = buf;
1070
1071 if (!hibernation_available())
1072 return sprintf(buf, fmt: "[disabled]\n");
1073
1074 for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
1075 if (!hibernation_modes[i])
1076 continue;
1077 switch (i) {
1078 case HIBERNATION_SHUTDOWN:
1079 case HIBERNATION_REBOOT:
1080#ifdef CONFIG_SUSPEND
1081 case HIBERNATION_SUSPEND:
1082#endif
1083 case HIBERNATION_TEST_RESUME:
1084 break;
1085 case HIBERNATION_PLATFORM:
1086 if (hibernation_ops)
1087 break;
1088 /* not a valid mode, continue with loop */
1089 continue;
1090 }
1091 if (i == hibernation_mode)
1092 buf += sprintf(buf, fmt: "[%s] ", hibernation_modes[i]);
1093 else
1094 buf += sprintf(buf, fmt: "%s ", hibernation_modes[i]);
1095 }
1096 buf += sprintf(buf, fmt: "\n");
1097 return buf-start;
1098}
1099
1100static ssize_t disk_store(struct kobject *kobj, struct kobj_attribute *attr,
1101 const char *buf, size_t n)
1102{
1103 int mode = HIBERNATION_INVALID;
1104 unsigned int sleep_flags;
1105 int error = 0;
1106 int len;
1107 char *p;
1108 int i;
1109
1110 if (!hibernation_available())
1111 return -EPERM;
1112
1113 p = memchr(p: buf, c: '\n', size: n);
1114 len = p ? p - buf : n;
1115
1116 sleep_flags = lock_system_sleep();
1117 for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
1118 if (len == strlen(hibernation_modes[i])
1119 && !strncmp(buf, hibernation_modes[i], len)) {
1120 mode = i;
1121 break;
1122 }
1123 }
1124 if (mode != HIBERNATION_INVALID) {
1125 switch (mode) {
1126 case HIBERNATION_SHUTDOWN:
1127 case HIBERNATION_REBOOT:
1128#ifdef CONFIG_SUSPEND
1129 case HIBERNATION_SUSPEND:
1130#endif
1131 case HIBERNATION_TEST_RESUME:
1132 hibernation_mode = mode;
1133 break;
1134 case HIBERNATION_PLATFORM:
1135 if (hibernation_ops)
1136 hibernation_mode = mode;
1137 else
1138 error = -EINVAL;
1139 }
1140 } else
1141 error = -EINVAL;
1142
1143 if (!error)
1144 pm_pr_dbg("Hibernation mode set to '%s'\n",
1145 hibernation_modes[mode]);
1146 unlock_system_sleep(sleep_flags);
1147 return error ? error : n;
1148}
1149
1150power_attr(disk);
1151
1152static ssize_t resume_show(struct kobject *kobj, struct kobj_attribute *attr,
1153 char *buf)
1154{
1155 return sprintf(buf, fmt: "%d:%d\n", MAJOR(swsusp_resume_device),
1156 MINOR(swsusp_resume_device));
1157}
1158
1159static ssize_t resume_store(struct kobject *kobj, struct kobj_attribute *attr,
1160 const char *buf, size_t n)
1161{
1162 unsigned int sleep_flags;
1163 int len = n;
1164 char *name;
1165 dev_t dev;
1166 int error;
1167
1168 if (!hibernation_available())
1169 return n;
1170
1171 if (len && buf[len-1] == '\n')
1172 len--;
1173 name = kstrndup(s: buf, len, GFP_KERNEL);
1174 if (!name)
1175 return -ENOMEM;
1176
1177 error = lookup_bdev(pathname: name, dev: &dev);
1178 if (error) {
1179 unsigned maj, min, offset;
1180 char *p, dummy;
1181
1182 error = 0;
1183 if (sscanf(name, "%u:%u%c", &maj, &min, &dummy) == 2 ||
1184 sscanf(name, "%u:%u:%u:%c", &maj, &min, &offset,
1185 &dummy) == 3) {
1186 dev = MKDEV(maj, min);
1187 if (maj != MAJOR(dev) || min != MINOR(dev))
1188 error = -EINVAL;
1189 } else {
1190 dev = new_decode_dev(dev: simple_strtoul(name, &p, 16));
1191 if (*p)
1192 error = -EINVAL;
1193 }
1194 }
1195 kfree(objp: name);
1196 if (error)
1197 return error;
1198
1199 sleep_flags = lock_system_sleep();
1200 swsusp_resume_device = dev;
1201 unlock_system_sleep(sleep_flags);
1202
1203 pm_pr_dbg("Configured hibernation resume from disk to %u\n",
1204 swsusp_resume_device);
1205 noresume = 0;
1206 software_resume();
1207 return n;
1208}
1209
1210power_attr(resume);
1211
1212static ssize_t resume_offset_show(struct kobject *kobj,
1213 struct kobj_attribute *attr, char *buf)
1214{
1215 return sprintf(buf, fmt: "%llu\n", (unsigned long long)swsusp_resume_block);
1216}
1217
1218static ssize_t resume_offset_store(struct kobject *kobj,
1219 struct kobj_attribute *attr, const char *buf,
1220 size_t n)
1221{
1222 unsigned long long offset;
1223 int rc;
1224
1225 rc = kstrtoull(s: buf, base: 0, res: &offset);
1226 if (rc)
1227 return rc;
1228 swsusp_resume_block = offset;
1229
1230 return n;
1231}
1232
1233power_attr(resume_offset);
1234
1235static ssize_t image_size_show(struct kobject *kobj, struct kobj_attribute *attr,
1236 char *buf)
1237{
1238 return sprintf(buf, fmt: "%lu\n", image_size);
1239}
1240
1241static ssize_t image_size_store(struct kobject *kobj, struct kobj_attribute *attr,
1242 const char *buf, size_t n)
1243{
1244 unsigned long size;
1245
1246 if (sscanf(buf, "%lu", &size) == 1) {
1247 image_size = size;
1248 return n;
1249 }
1250
1251 return -EINVAL;
1252}
1253
1254power_attr(image_size);
1255
1256static ssize_t reserved_size_show(struct kobject *kobj,
1257 struct kobj_attribute *attr, char *buf)
1258{
1259 return sprintf(buf, fmt: "%lu\n", reserved_size);
1260}
1261
1262static ssize_t reserved_size_store(struct kobject *kobj,
1263 struct kobj_attribute *attr,
1264 const char *buf, size_t n)
1265{
1266 unsigned long size;
1267
1268 if (sscanf(buf, "%lu", &size) == 1) {
1269 reserved_size = size;
1270 return n;
1271 }
1272
1273 return -EINVAL;
1274}
1275
1276power_attr(reserved_size);
1277
1278static struct attribute *g[] = {
1279 &disk_attr.attr,
1280 &resume_offset_attr.attr,
1281 &resume_attr.attr,
1282 &image_size_attr.attr,
1283 &reserved_size_attr.attr,
1284 NULL,
1285};
1286
1287
1288static const struct attribute_group attr_group = {
1289 .attrs = g,
1290};
1291
1292
1293static int __init pm_disk_init(void)
1294{
1295 return sysfs_create_group(kobj: power_kobj, grp: &attr_group);
1296}
1297
1298core_initcall(pm_disk_init);
1299
1300
1301static int __init resume_setup(char *str)
1302{
1303 if (noresume)
1304 return 1;
1305
1306 strncpy(p: resume_file, q: str, size: 255);
1307 return 1;
1308}
1309
1310static int __init resume_offset_setup(char *str)
1311{
1312 unsigned long long offset;
1313
1314 if (noresume)
1315 return 1;
1316
1317 if (sscanf(str, "%llu", &offset) == 1)
1318 swsusp_resume_block = offset;
1319
1320 return 1;
1321}
1322
1323static int __init hibernate_setup(char *str)
1324{
1325 if (!strncmp(str, "noresume", 8)) {
1326 noresume = 1;
1327 } else if (!strncmp(str, "nocompress", 10)) {
1328 nocompress = 1;
1329 } else if (!strncmp(str, "no", 2)) {
1330 noresume = 1;
1331 nohibernate = 1;
1332 } else if (IS_ENABLED(CONFIG_STRICT_KERNEL_RWX)
1333 && !strncmp(str, "protect_image", 13)) {
1334 enable_restore_image_protection();
1335 }
1336 return 1;
1337}
1338
1339static int __init noresume_setup(char *str)
1340{
1341 noresume = 1;
1342 return 1;
1343}
1344
1345static int __init resumewait_setup(char *str)
1346{
1347 resume_wait = 1;
1348 return 1;
1349}
1350
1351static int __init resumedelay_setup(char *str)
1352{
1353 int rc = kstrtouint(s: str, base: 0, res: &resume_delay);
1354
1355 if (rc)
1356 pr_warn("resumedelay: bad option string '%s'\n", str);
1357 return 1;
1358}
1359
1360static int __init nohibernate_setup(char *str)
1361{
1362 noresume = 1;
1363 nohibernate = 1;
1364 return 1;
1365}
1366
1367__setup("noresume", noresume_setup);
1368__setup("resume_offset=", resume_offset_setup);
1369__setup("resume=", resume_setup);
1370__setup("hibernate=", hibernate_setup);
1371__setup("resumewait", resumewait_setup);
1372__setup("resumedelay=", resumedelay_setup);
1373__setup("nohibernate", nohibernate_setup);
1374

source code of linux/kernel/power/hibernate.c