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