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