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