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