kernel/power/disk.c

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