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