1 // SPDX-License-Identifier: GPL-2.0-only 1
2 /*
3 * kernel/power/hibernate.c - Hibernation (a.k
4 *
5 * Copyright (c) 2003 Patrick Mochel
6 * Copyright (c) 2003 Open Source Development
7 * Copyright (c) 2004 Pavel Machek <pavel@ucw.
8 * Copyright (c) 2009 Rafael J. Wysocki, Novel
9 * Copyright (C) 2012 Bojan Smojver <bojan@rex
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
40 static int nocompress;
41 static int noresume;
42 static int nohibernate;
43 static int resume_wait;
44 static unsigned int resume_delay;
45 static char resume_file[256] = CONFIG_PM_STD_P
46 dev_t swsusp_resume_device;
47 sector_t swsusp_resume_block;
48 __visible int in_suspend __nosavedata;
49
50 static char hibernate_compressor[CRYPTO_MAX_AL
51
52 /*
53 * Compression/decompression algorithm to be u
54 * image to/from disk. This would later be use
55 * to allocate comp streams.
56 */
57 char hib_comp_algo[CRYPTO_MAX_ALG_NAME];
58
59 enum {
60 HIBERNATION_INVALID,
61 HIBERNATION_PLATFORM,
62 HIBERNATION_SHUTDOWN,
63 HIBERNATION_REBOOT,
64 #ifdef CONFIG_SUSPEND
65 HIBERNATION_SUSPEND,
66 #endif
67 HIBERNATION_TEST_RESUME,
68 /* keep last */
69 __HIBERNATION_AFTER_LAST
70 };
71 #define HIBERNATION_MAX (__HIBERNATION_AFTER_L
72 #define HIBERNATION_FIRST (HIBERNATION_INVALID
73
74 static int hibernation_mode = HIBERNATION_SHUT
75
76 bool freezer_test_done;
77
78 static const struct platform_hibernation_ops *
79
80 static atomic_t hibernate_atomic = ATOMIC_INIT
81
82 bool hibernate_acquire(void)
83 {
84 return atomic_add_unless(&hibernate_at
85 }
86
87 void hibernate_release(void)
88 {
89 atomic_inc(&hibernate_atomic);
90 }
91
92 bool hibernation_available(void)
93 {
94 return nohibernate == 0 &&
95 !security_locked_down(LOCKDOWN
96 !secretmem_active() && !cxl_me
97 }
98
99 /**
100 * hibernation_set_ops - Set the global hibern
101 * @ops: Hibernation operations to use in subs
102 */
103 void hibernation_set_ops(const struct platform
104 {
105 unsigned int sleep_flags;
106
107 if (ops && !(ops->begin && ops->end &&
108 && ops->prepare && ops->finish &&
109 && ops->restore_cleanup && ops->le
110 WARN_ON(1);
111 return;
112 }
113
114 sleep_flags = lock_system_sleep();
115
116 hibernation_ops = ops;
117 if (ops)
118 hibernation_mode = HIBERNATION
119 else if (hibernation_mode == HIBERNATI
120 hibernation_mode = HIBERNATION
121
122 unlock_system_sleep(sleep_flags);
123 }
124 EXPORT_SYMBOL_GPL(hibernation_set_ops);
125
126 static bool entering_platform_hibernation;
127
128 bool system_entering_hibernation(void)
129 {
130 return entering_platform_hibernation;
131 }
132 EXPORT_SYMBOL(system_entering_hibernation);
133
134 #ifdef CONFIG_PM_DEBUG
135 static void hibernation_debug_sleep(void)
136 {
137 pr_info("debug: Waiting for 5 seconds.
138 mdelay(5000);
139 }
140
141 static int hibernation_test(int level)
142 {
143 if (pm_test_level == level) {
144 hibernation_debug_sleep();
145 return 1;
146 }
147 return 0;
148 }
149 #else /* !CONFIG_PM_DEBUG */
150 static int hibernation_test(int level) { retur
151 #endif /* !CONFIG_PM_DEBUG */
152
153 /**
154 * platform_begin - Call platform to start hib
155 * @platform_mode: Whether or not to use the p
156 */
157 static int platform_begin(int platform_mode)
158 {
159 return (platform_mode && hibernation_o
160 hibernation_ops->begin(PMSG_FR
161 }
162
163 /**
164 * platform_end - Call platform to finish tran
165 * @platform_mode: Whether or not to use the p
166 */
167 static void platform_end(int platform_mode)
168 {
169 if (platform_mode && hibernation_ops)
170 hibernation_ops->end();
171 }
172
173 /**
174 * platform_pre_snapshot - Call platform to pr
175 * @platform_mode: Whether or not to use the p
176 *
177 * Use the platform driver to prepare the syst
178 * if so configured, and return an error code
179 */
180
181 static int platform_pre_snapshot(int platform_
182 {
183 return (platform_mode && hibernation_o
184 hibernation_ops->pre_snapshot(
185 }
186
187 /**
188 * platform_leave - Call platform to prepare a
189 * @platform_mode: Whether or not to use the p
190 *
191 * Use the platform driver prepare to prepare
192 * normal mode of operation.
193 *
194 * This routine is called on one CPU with inte
195 */
196 static void platform_leave(int platform_mode)
197 {
198 if (platform_mode && hibernation_ops)
199 hibernation_ops->leave();
200 }
201
202 /**
203 * platform_finish - Call platform to switch t
204 * @platform_mode: Whether or not to use the p
205 *
206 * Use the platform driver to switch the machi
207 * operation.
208 *
209 * This routine must be called after platform_
210 */
211 static void platform_finish(int platform_mode)
212 {
213 if (platform_mode && hibernation_ops)
214 hibernation_ops->finish();
215 }
216
217 /**
218 * platform_pre_restore - Prepare for hibernat
219 * @platform_mode: Whether or not to use the p
220 *
221 * Use the platform driver to prepare the syst
222 * image.
223 *
224 * If the restore fails after this function ha
225 * platform_restore_cleanup() must be called.
226 */
227 static int platform_pre_restore(int platform_m
228 {
229 return (platform_mode && hibernation_o
230 hibernation_ops->pre_restore()
231 }
232
233 /**
234 * platform_restore_cleanup - Switch to the wo
235 * @platform_mode: Whether or not to use the p
236 *
237 * Use the platform driver to switch the syste
238 * after a failing restore.
239 *
240 * If platform_pre_restore() has been called b
241 * function must be called too, regardless of
242 * platform_pre_restore().
243 */
244 static void platform_restore_cleanup(int platf
245 {
246 if (platform_mode && hibernation_ops)
247 hibernation_ops->restore_clean
248 }
249
250 /**
251 * platform_recover - Recover from a failure t
252 * @platform_mode: Whether or not to use the p
253 */
254 static void platform_recover(int platform_mode
255 {
256 if (platform_mode && hibernation_ops &
257 hibernation_ops->recover();
258 }
259
260 /**
261 * swsusp_show_speed - Print time elapsed betw
262 * @start: Starting event.
263 * @stop: Final event.
264 * @nr_pages: Number of memory pages processed
265 * @msg: Additional diagnostic message to prin
266 */
267 void swsusp_show_speed(ktime_t start, ktime_t
268 unsigned nr_pages, char
269 {
270 ktime_t diff;
271 u64 elapsed_centisecs64;
272 unsigned int centisecs;
273 unsigned int k;
274 unsigned int kps;
275
276 diff = ktime_sub(stop, start);
277 elapsed_centisecs64 = ktime_divns(diff
278 centisecs = elapsed_centisecs64;
279 if (centisecs == 0)
280 centisecs = 1; /* avoid div-b
281 k = nr_pages * (PAGE_SIZE / 1024);
282 kps = (k * 100) / centisecs;
283 pr_info("%s %u kbytes in %u.%02u secon
284 msg, k, centisecs / 100, centi
285 (kps % 1000) / 10);
286 }
287
288 __weak int arch_resume_nosmt(void)
289 {
290 return 0;
291 }
292
293 /**
294 * create_image - Create a hibernation image.
295 * @platform_mode: Whether or not to use the p
296 *
297 * Execute device drivers' "late" and "noirq"
298 * hibernation image and run the drivers' "noi
299 *
300 * Control reappears in this routine after the
301 */
302 static int create_image(int platform_mode)
303 {
304 int error;
305
306 error = dpm_suspend_end(PMSG_FREEZE);
307 if (error) {
308 pr_err("Some devices failed to
309 return error;
310 }
311
312 error = platform_pre_snapshot(platform
313 if (error || hibernation_test(TEST_PLA
314 goto Platform_finish;
315
316 error = pm_sleep_disable_secondary_cpu
317 if (error || hibernation_test(TEST_CPU
318 goto Enable_cpus;
319
320 local_irq_disable();
321
322 system_state = SYSTEM_SUSPEND;
323
324 error = syscore_suspend();
325 if (error) {
326 pr_err("Some system devices fa
327 goto Enable_irqs;
328 }
329
330 if (hibernation_test(TEST_CORE) || pm_
331 goto Power_up;
332
333 in_suspend = 1;
334 save_processor_state();
335 trace_suspend_resume(TPS("machine_susp
336 error = swsusp_arch_suspend();
337 /* Restore control flow magically appe
338 restore_processor_state();
339 trace_suspend_resume(TPS("machine_susp
340 if (error)
341 pr_err("Error %d creating imag
342
343 if (!in_suspend) {
344 events_check_enabled = false;
345 clear_or_poison_free_pages();
346 }
347
348 platform_leave(platform_mode);
349
350 Power_up:
351 syscore_resume();
352
353 Enable_irqs:
354 system_state = SYSTEM_RUNNING;
355 local_irq_enable();
356
357 Enable_cpus:
358 pm_sleep_enable_secondary_cpus();
359
360 /* Allow architectures to do nosmt-spe
361 if (!in_suspend)
362 error = arch_resume_nosmt();
363
364 Platform_finish:
365 platform_finish(platform_mode);
366
367 dpm_resume_start(in_suspend ?
368 (error ? PMSG_RECOVER : PMSG_T
369
370 return error;
371 }
372
373 /**
374 * hibernation_snapshot - Quiesce devices and
375 * @platform_mode: If set, use platform driver
376 *
377 * This routine must be called with system_tra
378 */
379 int hibernation_snapshot(int platform_mode)
380 {
381 pm_message_t msg;
382 int error;
383
384 pm_suspend_clear_flags();
385 error = platform_begin(platform_mode);
386 if (error)
387 goto Close;
388
389 /* Preallocate image memory before shu
390 error = hibernate_preallocate_memory()
391 if (error)
392 goto Close;
393
394 error = freeze_kernel_threads();
395 if (error)
396 goto Cleanup;
397
398 if (hibernation_test(TEST_FREEZER)) {
399
400 /*
401 * Indicate to the caller that
402 * successful freezer test.
403 */
404 freezer_test_done = true;
405 goto Thaw;
406 }
407
408 error = dpm_prepare(PMSG_FREEZE);
409 if (error) {
410 dpm_complete(PMSG_RECOVER);
411 goto Thaw;
412 }
413
414 suspend_console();
415 pm_restrict_gfp_mask();
416
417 error = dpm_suspend(PMSG_FREEZE);
418
419 if (error || hibernation_test(TEST_DEV
420 platform_recover(platform_mode
421 else
422 error = create_image(platform_
423
424 /*
425 * In the case that we call create_ima
426 * returns here (1) after the image ha
427 * image creation has failed and (2) a
428 */
429
430 /* We may need to release the prealloc
431 if (error || !in_suspend)
432 swsusp_free();
433
434 msg = in_suspend ? (error ? PMSG_RECOV
435 dpm_resume(msg);
436
437 if (error || !in_suspend)
438 pm_restore_gfp_mask();
439
440 resume_console();
441 dpm_complete(msg);
442
443 Close:
444 platform_end(platform_mode);
445 return error;
446
447 Thaw:
448 thaw_kernel_threads();
449 Cleanup:
450 swsusp_free();
451 goto Close;
452 }
453
454 int __weak hibernate_resume_nonboot_cpu_disabl
455 {
456 return suspend_disable_secondary_cpus(
457 }
458
459 /**
460 * resume_target_kernel - Restore system state
461 * @platform_mode: Whether or not to use the p
462 *
463 * Execute device drivers' "noirq" and "late"
464 * contents of highmem that have not been rest
465 * the low-level code that will restore the re
466 * switch to the just restored target kernel.
467 */
468 static int resume_target_kernel(bool platform_
469 {
470 int error;
471
472 error = dpm_suspend_end(PMSG_QUIESCE);
473 if (error) {
474 pr_err("Some devices failed to
475 return error;
476 }
477
478 error = platform_pre_restore(platform_
479 if (error)
480 goto Cleanup;
481
482 cpuidle_pause();
483
484 error = hibernate_resume_nonboot_cpu_d
485 if (error)
486 goto Enable_cpus;
487
488 local_irq_disable();
489 system_state = SYSTEM_SUSPEND;
490
491 error = syscore_suspend();
492 if (error)
493 goto Enable_irqs;
494
495 save_processor_state();
496 error = restore_highmem();
497 if (!error) {
498 error = swsusp_arch_resume();
499 /*
500 * The code below is only ever
501 * Otherwise, execution contin
502 * swsusp_arch_suspend() was c
503 */
504 BUG_ON(!error);
505 /*
506 * This call to restore_highme
507 * the previous one.
508 */
509 restore_highmem();
510 }
511 /*
512 * The only reason why swsusp_arch_res
513 * very tight, so we have to free it a
514 * subsequent failures.
515 */
516 swsusp_free();
517 restore_processor_state();
518 touch_softlockup_watchdog();
519
520 syscore_resume();
521
522 Enable_irqs:
523 system_state = SYSTEM_RUNNING;
524 local_irq_enable();
525
526 Enable_cpus:
527 pm_sleep_enable_secondary_cpus();
528
529 Cleanup:
530 platform_restore_cleanup(platform_mode
531
532 dpm_resume_start(PMSG_RECOVER);
533
534 return error;
535 }
536
537 /**
538 * hibernation_restore - Quiesce devices and r
539 * @platform_mode: If set, use platform driver
540 *
541 * This routine must be called with system_tra
542 * successful, control reappears in the restor
543 * hibernation_snapshot().
544 */
545 int hibernation_restore(int platform_mode)
546 {
547 int error;
548
549 pm_prepare_console();
550 suspend_console();
551 pm_restrict_gfp_mask();
552 error = dpm_suspend_start(PMSG_QUIESCE
553 if (!error) {
554 error = resume_target_kernel(p
555 /*
556 * The above should either suc
557 * or return with an error. Ot
558 * undefined, so let's be para
559 */
560 BUG_ON(!error);
561 }
562 dpm_resume_end(PMSG_RECOVER);
563 pm_restore_gfp_mask();
564 resume_console();
565 pm_restore_console();
566 return error;
567 }
568
569 /**
570 * hibernation_platform_enter - Power off the
571 */
572 int hibernation_platform_enter(void)
573 {
574 int error;
575
576 if (!hibernation_ops)
577 return -ENOSYS;
578
579 /*
580 * We have cancelled the power transit
581 * hibernation_ops->finish() before sa
582 * the firmware know that we're going
583 */
584 error = hibernation_ops->begin(PMSG_HI
585 if (error)
586 goto Close;
587
588 entering_platform_hibernation = true;
589 suspend_console();
590 error = dpm_suspend_start(PMSG_HIBERNA
591 if (error) {
592 if (hibernation_ops->recover)
593 hibernation_ops->recov
594 goto Resume_devices;
595 }
596
597 error = dpm_suspend_end(PMSG_HIBERNATE
598 if (error)
599 goto Resume_devices;
600
601 error = hibernation_ops->prepare();
602 if (error)
603 goto Platform_finish;
604
605 error = pm_sleep_disable_secondary_cpu
606 if (error)
607 goto Enable_cpus;
608
609 local_irq_disable();
610 system_state = SYSTEM_SUSPEND;
611 syscore_suspend();
612 if (pm_wakeup_pending()) {
613 error = -EAGAIN;
614 goto Power_up;
615 }
616
617 hibernation_ops->enter();
618 /* We should never get here */
619 while (1);
620
621 Power_up:
622 syscore_resume();
623 system_state = SYSTEM_RUNNING;
624 local_irq_enable();
625
626 Enable_cpus:
627 pm_sleep_enable_secondary_cpus();
628
629 Platform_finish:
630 hibernation_ops->finish();
631
632 dpm_resume_start(PMSG_RESTORE);
633
634 Resume_devices:
635 entering_platform_hibernation = false;
636 dpm_resume_end(PMSG_RESTORE);
637 resume_console();
638
639 Close:
640 hibernation_ops->end();
641
642 return error;
643 }
644
645 /**
646 * power_down - Shut the machine down for hibe
647 *
648 * Use the platform driver, if configured, to
649 * state corresponding to hibernation, or try
650 * depending on the value of hibernation_mode.
651 */
652 static void power_down(void)
653 {
654 int error;
655
656 #ifdef CONFIG_SUSPEND
657 if (hibernation_mode == HIBERNATION_SU
658 error = suspend_devices_and_en
659 if (error) {
660 hibernation_mode = hib
661
662
663 } else {
664 /* Restore swap signat
665 error = swsusp_unmark(
666 if (error)
667 pr_err("Swap w
668
669 return;
670 }
671 }
672 #endif
673
674 switch (hibernation_mode) {
675 case HIBERNATION_REBOOT:
676 kernel_restart(NULL);
677 break;
678 case HIBERNATION_PLATFORM:
679 error = hibernation_platform_e
680 if (error == -EAGAIN || error
681 swsusp_unmark();
682 events_check_enabled =
683 pr_info("Wakeup event
684 return;
685 }
686 fallthrough;
687 case HIBERNATION_SHUTDOWN:
688 if (kernel_can_power_off())
689 kernel_power_off();
690 break;
691 }
692 kernel_halt();
693 /*
694 * Valid image is on the disk, if we c
695 * corruption after resume.
696 */
697 pr_crit("Power down manually\n");
698 while (1)
699 cpu_relax();
700 }
701
702 static int load_image_and_restore(void)
703 {
704 int error;
705 unsigned int flags;
706
707 pm_pr_dbg("Loading hibernation image.\
708
709 lock_device_hotplug();
710 error = create_basic_memory_bitmaps();
711 if (error) {
712 swsusp_close();
713 goto Unlock;
714 }
715
716 error = swsusp_read(&flags);
717 swsusp_close();
718 if (!error)
719 error = hibernation_restore(fl
720
721 pr_err("Failed to load image, recoveri
722 swsusp_free();
723 free_basic_memory_bitmaps();
724 Unlock:
725 unlock_device_hotplug();
726
727 return error;
728 }
729
730 #define COMPRESSION_ALGO_LZO "lzo"
731 #define COMPRESSION_ALGO_LZ4 "lz4"
732
733 /**
734 * hibernate - Carry out system hibernation, i
735 */
736 int hibernate(void)
737 {
738 bool snapshot_test = false;
739 unsigned int sleep_flags;
740 int error;
741
742 if (!hibernation_available()) {
743 pm_pr_dbg("Hibernation not ava
744 return -EPERM;
745 }
746
747 /*
748 * Query for the compression algorithm
749 */
750 if (!nocompress) {
751 strscpy(hib_comp_algo, hiberna
752 if (crypto_has_comp(hib_comp_a
753 pr_err("%s compression
754 return -EOPNOTSUPP;
755 }
756 }
757
758 sleep_flags = lock_system_sleep();
759 /* The snapshot device should not be o
760 if (!hibernate_acquire()) {
761 error = -EBUSY;
762 goto Unlock;
763 }
764
765 pr_info("hibernation entry\n");
766 pm_prepare_console();
767 error = pm_notifier_call_chain_robust(
768 if (error)
769 goto Restore;
770
771 ksys_sync_helper();
772
773 error = freeze_processes();
774 if (error)
775 goto Exit;
776
777 lock_device_hotplug();
778 /* Allocate memory management structur
779 error = create_basic_memory_bitmaps();
780 if (error)
781 goto Thaw;
782
783 error = hibernation_snapshot(hibernati
784 if (error || freezer_test_done)
785 goto Free_bitmaps;
786
787 if (in_suspend) {
788 unsigned int flags = 0;
789
790 if (hibernation_mode == HIBERN
791 flags |= SF_PLATFORM_M
792 if (nocompress) {
793 flags |= SF_NOCOMPRESS
794 } else {
795 flags |= SF_CRC32_MODE
796
797 /*
798 * By default, LZO com
799 * to override this be
800 *
801 * Refer kernel/power/
802 */
803
804 if (!strcmp(hib_comp_a
805 flags |= SF_CO
806 else
807 flags |= SF_CO
808 }
809
810 pm_pr_dbg("Writing hibernation
811 error = swsusp_write(flags);
812 swsusp_free();
813 if (!error) {
814 if (hibernation_mode =
815 snapshot_test
816 else
817 power_down();
818 }
819 in_suspend = 0;
820 pm_restore_gfp_mask();
821 } else {
822 pm_pr_dbg("Hibernation image r
823 }
824
825 Free_bitmaps:
826 free_basic_memory_bitmaps();
827 Thaw:
828 unlock_device_hotplug();
829 if (snapshot_test) {
830 pm_pr_dbg("Checking hibernatio
831 error = swsusp_check(false);
832 if (!error)
833 error = load_image_and
834 }
835 thaw_processes();
836
837 /* Don't bother checking whether freez
838 freezer_test_done = false;
839 Exit:
840 pm_notifier_call_chain(PM_POST_HIBERNA
841 Restore:
842 pm_restore_console();
843 hibernate_release();
844 Unlock:
845 unlock_system_sleep(sleep_flags);
846 pr_info("hibernation exit\n");
847
848 return error;
849 }
850
851 /**
852 * hibernate_quiet_exec - Execute a function w
853 * @func: Function to execute.
854 * @data: Data pointer to pass to @func.
855 *
856 * Return the @func return value or an error c
857 */
858 int hibernate_quiet_exec(int (*func)(void *dat
859 {
860 unsigned int sleep_flags;
861 int error;
862
863 sleep_flags = lock_system_sleep();
864
865 if (!hibernate_acquire()) {
866 error = -EBUSY;
867 goto unlock;
868 }
869
870 pm_prepare_console();
871
872 error = pm_notifier_call_chain_robust(
873 if (error)
874 goto restore;
875
876 error = freeze_processes();
877 if (error)
878 goto exit;
879
880 lock_device_hotplug();
881
882 pm_suspend_clear_flags();
883
884 error = platform_begin(true);
885 if (error)
886 goto thaw;
887
888 error = freeze_kernel_threads();
889 if (error)
890 goto thaw;
891
892 error = dpm_prepare(PMSG_FREEZE);
893 if (error)
894 goto dpm_complete;
895
896 suspend_console();
897
898 error = dpm_suspend(PMSG_FREEZE);
899 if (error)
900 goto dpm_resume;
901
902 error = dpm_suspend_end(PMSG_FREEZE);
903 if (error)
904 goto dpm_resume;
905
906 error = platform_pre_snapshot(true);
907 if (error)
908 goto skip;
909
910 error = func(data);
911
912 skip:
913 platform_finish(true);
914
915 dpm_resume_start(PMSG_THAW);
916
917 dpm_resume:
918 dpm_resume(PMSG_THAW);
919
920 resume_console();
921
922 dpm_complete:
923 dpm_complete(PMSG_THAW);
924
925 thaw_kernel_threads();
926
927 thaw:
928 platform_end(true);
929
930 unlock_device_hotplug();
931
932 thaw_processes();
933
934 exit:
935 pm_notifier_call_chain(PM_POST_HIBERNA
936
937 restore:
938 pm_restore_console();
939
940 hibernate_release();
941
942 unlock:
943 unlock_system_sleep(sleep_flags);
944
945 return error;
946 }
947 EXPORT_SYMBOL_GPL(hibernate_quiet_exec);
948
949 static int __init find_resume_device(void)
950 {
951 if (!strlen(resume_file))
952 return -ENOENT;
953
954 pm_pr_dbg("Checking hibernation image
955
956 if (resume_delay) {
957 pr_info("Waiting %dsec before
958 resume_delay);
959 ssleep(resume_delay);
960 }
961
962 /* Check if the device is there */
963 if (!early_lookup_bdev(resume_file, &s
964 return 0;
965
966 /*
967 * Some device discovery might still b
968 * this to finish.
969 */
970 wait_for_device_probe();
971 if (resume_wait) {
972 while (early_lookup_bdev(resum
973 msleep(10);
974 async_synchronize_full();
975 }
976
977 return early_lookup_bdev(resume_file,
978 }
979
980 static int software_resume(void)
981 {
982 int error;
983
984 pm_pr_dbg("Hibernation image partition
985 MAJOR(swsusp_resume_device), M
986
987 pm_pr_dbg("Looking for hibernation ima
988
989 mutex_lock(&system_transition_mutex);
990 error = swsusp_check(true);
991 if (error)
992 goto Unlock;
993
994 /*
995 * Check if the hibernation image is c
996 * the algorithm support.
997 */
998 if (!(swsusp_header_flags & SF_NOCOMPR
999 if (swsusp_header_flags & SF_C
1000 strscpy(hib_comp_algo
1001 else
1002 strscpy(hib_comp_algo
1003 if (crypto_has_comp(hib_comp_
1004 pr_err("%s compressio
1005 error = -EOPNOTSUPP;
1006 goto Unlock;
1007 }
1008 }
1009
1010 /* The snapshot device should not be
1011 if (!hibernate_acquire()) {
1012 error = -EBUSY;
1013 swsusp_close();
1014 goto Unlock;
1015 }
1016
1017 pr_info("resume from hibernation\n");
1018 pm_prepare_console();
1019 error = pm_notifier_call_chain_robust
1020 if (error)
1021 goto Restore;
1022
1023 pm_pr_dbg("Preparing processes for hi
1024 error = freeze_processes();
1025 if (error)
1026 goto Close_Finish;
1027
1028 error = freeze_kernel_threads();
1029 if (error) {
1030 thaw_processes();
1031 goto Close_Finish;
1032 }
1033
1034 error = load_image_and_restore();
1035 thaw_processes();
1036 Finish:
1037 pm_notifier_call_chain(PM_POST_RESTOR
1038 Restore:
1039 pm_restore_console();
1040 pr_info("resume failed (%d)\n", error
1041 hibernate_release();
1042 /* For success case, the suspend path
1043 Unlock:
1044 mutex_unlock(&system_transition_mutex
1045 pm_pr_dbg("Hibernation image not pres
1046 return error;
1047 Close_Finish:
1048 swsusp_close();
1049 goto Finish;
1050 }
1051
1052 /**
1053 * software_resume_initcall - Resume from a s
1054 *
1055 * This routine is called as a late initcall,
1056 * discovered and initialized already.
1057 *
1058 * The image reading code is called to see if
1059 * available for reading. If that is the cas
1060 * contents of memory is restored from the sa
1061 *
1062 * If this is successful, control reappears i
1063 * hibernation_snapshot() which returns to hi
1064 * attempts to recover gracefully and make th
1065 * of operation.
1066 */
1067 static int __init software_resume_initcall(vo
1068 {
1069 /*
1070 * If the user said "noresume".. bail
1071 */
1072 if (noresume || !hibernation_availabl
1073 return 0;
1074
1075 if (!swsusp_resume_device) {
1076 int error = find_resume_devic
1077
1078 if (error)
1079 return error;
1080 }
1081
1082 return software_resume();
1083 }
1084 late_initcall_sync(software_resume_initcall);
1085
1086
1087 static const char * const hibernation_modes[]
1088 [HIBERNATION_PLATFORM] = "platform",
1089 [HIBERNATION_SHUTDOWN] = "shutdown",
1090 [HIBERNATION_REBOOT] = "reboot",
1091 #ifdef CONFIG_SUSPEND
1092 [HIBERNATION_SUSPEND] = "suspend",
1093 #endif
1094 [HIBERNATION_TEST_RESUME] = "te
1095 };
1096
1097 /*
1098 * /sys/power/disk - Control hibernation mode
1099 *
1100 * Hibernation can be handled in several ways
1101 * to put the system into the sleep state: us
1102 * or other hibernation_ops), powering it off
1103 * mostly).
1104 *
1105 * The sysfs file /sys/power/disk provides an
1106 * hibernation mode to use. Reading from thi
1107 * to be printed. There are 3 modes that can
1108 *
1109 * 'platform'
1110 * 'shutdown'
1111 * 'reboot'
1112 *
1113 * If a platform hibernation driver is in use
1114 * and will be used by default. Otherwise, '
1115 * The selected option (i.e. the one correspo
1116 * hibernation_mode) is enclosed by a square
1117 *
1118 * To select a given hibernation mode it is n
1119 * string representation (as returned by read
1120 * into /sys/power/disk.
1121 */
1122
1123 static ssize_t disk_show(struct kobject *kobj
1124 char *buf)
1125 {
1126 ssize_t count = 0;
1127 int i;
1128
1129 if (!hibernation_available())
1130 return sysfs_emit(buf, "[disa
1131
1132 for (i = HIBERNATION_FIRST; i <= HIBE
1133 if (!hibernation_modes[i])
1134 continue;
1135 switch (i) {
1136 case HIBERNATION_SHUTDOWN:
1137 case HIBERNATION_REBOOT:
1138 #ifdef CONFIG_SUSPEND
1139 case HIBERNATION_SUSPEND:
1140 #endif
1141 case HIBERNATION_TEST_RESUME:
1142 break;
1143 case HIBERNATION_PLATFORM:
1144 if (hibernation_ops)
1145 break;
1146 /* not a valid mode,
1147 continue;
1148 }
1149 if (i == hibernation_mode)
1150 count += sysfs_emit_a
1151 else
1152 count += sysfs_emit_a
1153 }
1154
1155 /* Convert the last space to a newlin
1156 if (count > 0)
1157 buf[count - 1] = '\n';
1158
1159 return count;
1160 }
1161
1162 static ssize_t disk_store(struct kobject *kob
1163 const char *buf, si
1164 {
1165 int mode = HIBERNATION_INVALID;
1166 unsigned int sleep_flags;
1167 int error = 0;
1168 int len;
1169 char *p;
1170 int i;
1171
1172 if (!hibernation_available())
1173 return -EPERM;
1174
1175 p = memchr(buf, '\n', n);
1176 len = p ? p - buf : n;
1177
1178 sleep_flags = lock_system_sleep();
1179 for (i = HIBERNATION_FIRST; i <= HIBE
1180 if (len == strlen(hibernation
1181 && !strncmp(buf, hibernat
1182 mode = i;
1183 break;
1184 }
1185 }
1186 if (mode != HIBERNATION_INVALID) {
1187 switch (mode) {
1188 case HIBERNATION_SHUTDOWN:
1189 case HIBERNATION_REBOOT:
1190 #ifdef CONFIG_SUSPEND
1191 case HIBERNATION_SUSPEND:
1192 #endif
1193 case HIBERNATION_TEST_RESUME:
1194 hibernation_mode = mo
1195 break;
1196 case HIBERNATION_PLATFORM:
1197 if (hibernation_ops)
1198 hibernation_m
1199 else
1200 error = -EINV
1201 }
1202 } else
1203 error = -EINVAL;
1204
1205 if (!error)
1206 pm_pr_dbg("Hibernation mode s
1207 hibernation_mo
1208 unlock_system_sleep(sleep_flags);
1209 return error ? error : n;
1210 }
1211
1212 power_attr(disk);
1213
1214 static ssize_t resume_show(struct kobject *ko
1215 char *buf)
1216 {
1217 return sysfs_emit(buf, "%d:%d\n", MAJ
1218 MINOR(swsusp_resume
1219 }
1220
1221 static ssize_t resume_store(struct kobject *k
1222 const char *buf,
1223 {
1224 unsigned int sleep_flags;
1225 int len = n;
1226 char *name;
1227 dev_t dev;
1228 int error;
1229
1230 if (!hibernation_available())
1231 return n;
1232
1233 if (len && buf[len-1] == '\n')
1234 len--;
1235 name = kstrndup(buf, len, GFP_KERNEL)
1236 if (!name)
1237 return -ENOMEM;
1238
1239 error = lookup_bdev(name, &dev);
1240 if (error) {
1241 unsigned maj, min, offset;
1242 char *p, dummy;
1243
1244 error = 0;
1245 if (sscanf(name, "%u:%u%c", &
1246 sscanf(name, "%u:%u:%u:%c
1247 &dummy) == 3)
1248 dev = MKDEV(maj, min)
1249 if (maj != MAJOR(dev)
1250 error = -EINV
1251 } else {
1252 dev = new_decode_dev(
1253 if (*p)
1254 error = -EINV
1255 }
1256 }
1257 kfree(name);
1258 if (error)
1259 return error;
1260
1261 sleep_flags = lock_system_sleep();
1262 swsusp_resume_device = dev;
1263 unlock_system_sleep(sleep_flags);
1264
1265 pm_pr_dbg("Configured hibernation res
1266 swsusp_resume_device);
1267 noresume = 0;
1268 software_resume();
1269 return n;
1270 }
1271
1272 power_attr(resume);
1273
1274 static ssize_t resume_offset_show(struct kobj
1275 struct kobj
1276 {
1277 return sysfs_emit(buf, "%llu\n", (uns
1278 }
1279
1280 static ssize_t resume_offset_store(struct kob
1281 struct kob
1282 size_t n)
1283 {
1284 unsigned long long offset;
1285 int rc;
1286
1287 rc = kstrtoull(buf, 0, &offset);
1288 if (rc)
1289 return rc;
1290 swsusp_resume_block = offset;
1291
1292 return n;
1293 }
1294
1295 power_attr(resume_offset);
1296
1297 static ssize_t image_size_show(struct kobject
1298 char *buf)
1299 {
1300 return sysfs_emit(buf, "%lu\n", image
1301 }
1302
1303 static ssize_t image_size_store(struct kobjec
1304 const char *b
1305 {
1306 unsigned long size;
1307
1308 if (sscanf(buf, "%lu", &size) == 1) {
1309 image_size = size;
1310 return n;
1311 }
1312
1313 return -EINVAL;
1314 }
1315
1316 power_attr(image_size);
1317
1318 static ssize_t reserved_size_show(struct kobj
1319 struct kobj
1320 {
1321 return sysfs_emit(buf, "%lu\n", reser
1322 }
1323
1324 static ssize_t reserved_size_store(struct kob
1325 struct kob
1326 const char
1327 {
1328 unsigned long size;
1329
1330 if (sscanf(buf, "%lu", &size) == 1) {
1331 reserved_size = size;
1332 return n;
1333 }
1334
1335 return -EINVAL;
1336 }
1337
1338 power_attr(reserved_size);
1339
1340 static struct attribute *g[] = {
1341 &disk_attr.attr,
1342 &resume_offset_attr.attr,
1343 &resume_attr.attr,
1344 &image_size_attr.attr,
1345 &reserved_size_attr.attr,
1346 NULL,
1347 };
1348
1349
1350 static const struct attribute_group attr_grou
1351 .attrs = g,
1352 };
1353
1354
1355 static int __init pm_disk_init(void)
1356 {
1357 return sysfs_create_group(power_kobj,
1358 }
1359
1360 core_initcall(pm_disk_init);
1361
1362
1363 static int __init resume_setup(char *str)
1364 {
1365 if (noresume)
1366 return 1;
1367
1368 strscpy(resume_file, str);
1369 return 1;
1370 }
1371
1372 static int __init resume_offset_setup(char *s
1373 {
1374 unsigned long long offset;
1375
1376 if (noresume)
1377 return 1;
1378
1379 if (sscanf(str, "%llu", &offset) == 1
1380 swsusp_resume_block = offset;
1381
1382 return 1;
1383 }
1384
1385 static int __init hibernate_setup(char *str)
1386 {
1387 if (!strncmp(str, "noresume", 8)) {
1388 noresume = 1;
1389 } else if (!strncmp(str, "nocompress"
1390 nocompress = 1;
1391 } else if (!strncmp(str, "no", 2)) {
1392 noresume = 1;
1393 nohibernate = 1;
1394 } else if (IS_ENABLED(CONFIG_STRICT_K
1395 && !strncmp(str, "protect_
1396 enable_restore_image_protecti
1397 }
1398 return 1;
1399 }
1400
1401 static int __init noresume_setup(char *str)
1402 {
1403 noresume = 1;
1404 return 1;
1405 }
1406
1407 static int __init resumewait_setup(char *str)
1408 {
1409 resume_wait = 1;
1410 return 1;
1411 }
1412
1413 static int __init resumedelay_setup(char *str
1414 {
1415 int rc = kstrtouint(str, 0, &resume_d
1416
1417 if (rc)
1418 pr_warn("resumedelay: bad opt
1419 return 1;
1420 }
1421
1422 static int __init nohibernate_setup(char *str
1423 {
1424 noresume = 1;
1425 nohibernate = 1;
1426 return 1;
1427 }
1428
1429 static const char * const comp_alg_enabled[]
1430 #if IS_ENABLED(CONFIG_CRYPTO_LZO)
1431 COMPRESSION_ALGO_LZO,
1432 #endif
1433 #if IS_ENABLED(CONFIG_CRYPTO_LZ4)
1434 COMPRESSION_ALGO_LZ4,
1435 #endif
1436 };
1437
1438 static int hibernate_compressor_param_set(con
1439 const struct kernel_param *kp
1440 {
1441 unsigned int sleep_flags;
1442 int index, ret;
1443
1444 sleep_flags = lock_system_sleep();
1445
1446 index = sysfs_match_string(comp_alg_e
1447 if (index >= 0) {
1448 ret = param_set_copystring(co
1449 if (!ret)
1450 strscpy(hib_comp_algo
1451 sizeof(hib_co
1452 } else {
1453 ret = index;
1454 }
1455
1456 unlock_system_sleep(sleep_flags);
1457
1458 if (ret)
1459 pr_debug("Cannot set specifie
1460 compressor);
1461
1462 return ret;
1463 }
1464
1465 static const struct kernel_param_ops hibernat
1466 .set = hibernate_compressor_param_
1467 .get = param_get_string,
1468 };
1469
1470 static struct kparam_string hibernate_compres
1471 .maxlen = sizeof(hibernate_compressor
1472 .string = hibernate_compressor,
1473 };
1474
1475 module_param_cb(compressor, &hibernate_compre
1476 &hibernate_compressor_param_s
1477 MODULE_PARM_DESC(compressor,
1478 "Compression algorithm to be
1479
1480 __setup("noresume", noresume_setup);
1481 __setup("resume_offset=", resume_offset_setup
1482 __setup("resume=", resume_setup);
1483 __setup("hibernate=", hibernate_setup);
1484 __setup("resumewait", resumewait_setup);
1485 __setup("resumedelay=", resumedelay_setup);
1486 __setup("nohibernate", nohibernate_setup);
1487
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.