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 | |
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_PARTITION; |
46 | dev_t swsusp_resume_device; |
47 | sector_t swsusp_resume_block; |
48 | __visible int in_suspend __nosavedata; |
49 | |
50 | enum { |
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 | |
65 | static int hibernation_mode = HIBERNATION_SHUTDOWN; |
66 | |
67 | bool freezer_test_done; |
68 | |
69 | static const struct platform_hibernation_ops *hibernation_ops; |
70 | |
71 | static atomic_t hibernate_atomic = ATOMIC_INIT(1); |
72 | |
73 | bool hibernate_acquire(void) |
74 | { |
75 | return atomic_add_unless(v: &hibernate_atomic, a: -1, u: 0); |
76 | } |
77 | |
78 | void hibernate_release(void) |
79 | { |
80 | atomic_inc(v: &hibernate_atomic); |
81 | } |
82 | |
83 | bool 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 | */ |
94 | void 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 | } |
115 | EXPORT_SYMBOL_GPL(hibernation_set_ops); |
116 | |
117 | static bool entering_platform_hibernation; |
118 | |
119 | bool system_entering_hibernation(void) |
120 | { |
121 | return entering_platform_hibernation; |
122 | } |
123 | EXPORT_SYMBOL(system_entering_hibernation); |
124 | |
125 | #ifdef CONFIG_PM_DEBUG |
126 | static void hibernation_debug_sleep(void) |
127 | { |
128 | pr_info("debug: Waiting for 5 seconds.\n" ); |
129 | mdelay(5000); |
130 | } |
131 | |
132 | static 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 */ |
141 | static 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 | */ |
148 | static 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 | */ |
158 | static 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 | |
172 | static 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 | */ |
187 | static 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 | */ |
202 | static 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 | */ |
218 | static 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 | */ |
235 | static 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 | */ |
245 | static 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 | */ |
258 | void 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 | */ |
293 | static 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 | */ |
370 | int 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 | |
445 | int __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 | */ |
459 | static 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 | */ |
536 | int 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 | */ |
563 | int 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 | */ |
643 | static 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 | |
687 | static 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 | */ |
718 | int 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 | */ |
816 | int 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 | |
870 | skip: |
871 | platform_finish(platform_mode: true); |
872 | |
873 | dpm_resume_start(PMSG_THAW); |
874 | |
875 | dpm_resume: |
876 | dpm_resume(PMSG_THAW); |
877 | |
878 | resume_console(); |
879 | |
880 | dpm_complete: |
881 | dpm_complete(PMSG_THAW); |
882 | |
883 | thaw_kernel_threads(); |
884 | |
885 | thaw: |
886 | platform_end(platform_mode: true); |
887 | |
888 | unlock_device_hotplug(); |
889 | |
890 | thaw_processes(); |
891 | |
892 | exit: |
893 | pm_notifier_call_chain(PM_POST_HIBERNATION); |
894 | |
895 | restore: |
896 | pm_restore_console(); |
897 | |
898 | hibernate_release(); |
899 | |
900 | unlock: |
901 | unlock_system_sleep(sleep_flags); |
902 | |
903 | return error; |
904 | } |
905 | EXPORT_SYMBOL_GPL(hibernate_quiet_exec); |
906 | |
907 | static 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 | |
938 | static 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 | */ |
1009 | static 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 | } |
1026 | late_initcall_sync(software_resume_initcall); |
1027 | |
1028 | |
1029 | static 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 | |
1065 | static 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 | |
1100 | static 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 | |
1150 | power_attr(disk); |
1151 | |
1152 | static 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 | |
1159 | static 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 | |
1210 | power_attr(resume); |
1211 | |
1212 | static 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 | |
1218 | static 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 | |
1233 | power_attr(resume_offset); |
1234 | |
1235 | static 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 | |
1241 | static 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 | |
1254 | power_attr(image_size); |
1255 | |
1256 | static 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 | |
1262 | static 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 | |
1276 | power_attr(reserved_size); |
1277 | |
1278 | static 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 | |
1288 | static const struct attribute_group attr_group = { |
1289 | .attrs = g, |
1290 | }; |
1291 | |
1292 | |
1293 | static int __init pm_disk_init(void) |
1294 | { |
1295 | return sysfs_create_group(kobj: power_kobj, grp: &attr_group); |
1296 | } |
1297 | |
1298 | core_initcall(pm_disk_init); |
1299 | |
1300 | |
1301 | static 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 | |
1310 | static 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 | |
1323 | static 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 | |
1339 | static int __init noresume_setup(char *str) |
1340 | { |
1341 | noresume = 1; |
1342 | return 1; |
1343 | } |
1344 | |
1345 | static int __init resumewait_setup(char *str) |
1346 | { |
1347 | resume_wait = 1; |
1348 | return 1; |
1349 | } |
1350 | |
1351 | static 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 | |
1360 | static 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 | |