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/delay.h>
  18 #include <linux/fs.h>
  19 #include <linux/mount.h>
  20 #include <linux/pm.h>
  21 #include <linux/console.h>
  22 #include <linux/cpu.h>
  23 #include <linux/freezer.h>
  24
  25 #include "power.h"
  26
  27
  28 static int noresume = 0;
  29 char resume_file[256] = CONFIG_PM_STD_PARTITION;
  30 dev_t swsusp_resume_device;
  31 sector_t swsusp_resume_block;
  32
  33 enum {
  34         HIBERNATION_INVALID,
  35         HIBERNATION_PLATFORM,
  36         HIBERNATION_TEST,
  37         HIBERNATION_TESTPROC,
  38         HIBERNATION_SHUTDOWN,
  39         HIBERNATION_REBOOT,
  40         /* keep last */
  41         __HIBERNATION_AFTER_LAST
  42 };
  43 #define HIBERNATION_MAX (__HIBERNATION_AFTER_LAST-1)
  44 #define HIBERNATION_FIRST (HIBERNATION_INVALID + 1)
  45
  46 static int hibernation_mode = HIBERNATION_SHUTDOWN;
  47
  48 struct hibernation_ops *hibernation_ops;
  49
  50 /**
  51  * hibernation_set_ops - set the global hibernate operations
  52  * @ops: the hibernation operations to use in subsequent hibernation transitions
  53  */
  54
  55 void hibernation_set_ops(struct hibernation_ops *ops)
  56 {
  57         if (ops && !(ops->prepare && ops->enter && ops->finish)) {
  58                 WARN_ON(1);
  59                 return;
  60         }
  61         mutex_lock(&pm_mutex);
  62         hibernation_ops = ops;
  63         if (ops)
  64                 hibernation_mode = HIBERNATION_PLATFORM;
  65         else if (hibernation_mode == HIBERNATION_PLATFORM)
  66                 hibernation_mode = HIBERNATION_SHUTDOWN;
  67
  68         mutex_unlock(&pm_mutex);
  69 }
  70
  71
  72 /**
  73  *      platform_prepare - prepare the machine for hibernation using the
  74  *      platform driver if so configured and return an error code if it fails
  75  */
  76
  77 static int platform_prepare(void)
  78 {
  79         return (hibernation_mode == HIBERNATION_PLATFORM && hibernation_ops) ?
  80                 hibernation_ops->prepare() : 0;
  81 }
  82
  83 /**
  84  *      platform_finish - switch the machine to the normal mode of operation
  85  *      using the platform driver (must be called after platform_prepare())
  86  */
  87
  88 static void platform_finish(void)
  89 {
  90         if (hibernation_mode == HIBERNATION_PLATFORM && hibernation_ops)
  91                 hibernation_ops->finish();
  92 }
  93
  94 /**
  95  *      power_down - Shut the machine down for hibernation.
  96  *
  97  *      Use the platform driver, if configured so; otherwise try
  98  *      to power off or reboot.
  99  */
 100
 101 static void power_down(void)
 102 {
 103         switch (hibernation_mode) {
 104         case HIBERNATION_TEST:
 105         case HIBERNATION_TESTPROC:
 106                 break;
 107         case HIBERNATION_SHUTDOWN:
 108                 kernel_power_off();
 109                 break;
 110         case HIBERNATION_REBOOT:
 111                 kernel_restart(NULL);
 112                 break;
 113         case HIBERNATION_PLATFORM:
 114                 if (hibernation_ops) {
 115                         kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
 116                         hibernation_ops->enter();
 117                         break;
 118                 }
 119         }
 120         kernel_halt();
 121         /*
 122          * Valid image is on the disk, if we continue we risk serious data
 123          * corruption after resume.
 124          */
 125         printk(KERN_CRIT "Please power me down manually\n");
 126         while(1);
 127 }
 128
 129 static void unprepare_processes(void)
 130 {
 131         thaw_processes();
 132         pm_restore_console();
 133 }
 134
 135 static int prepare_processes(void)
 136 {
 137         int error = 0;
 138
 139         pm_prepare_console();
 140         if (freeze_processes()) {
 141                 error = -EBUSY;
 142                 unprepare_processes();
 143         }
 144         return error;
 145 }
 146
 147 /**
 148  *      hibernate - The granpappy of the built-in hibernation management
 149  */
 150
 151 int hibernate(void)
 152 {
 153         int error;
 154
 155         /* The snapshot device should not be opened while we're running */
 156         if (!atomic_add_unless(&snapshot_device_available, -1, 0))
 157                 return -EBUSY;
 158
 159         /* Allocate memory management structures */
 160         error = create_basic_memory_bitmaps();
 161         if (error)
 162                 goto Exit;
 163
 164         error = prepare_processes();
 165         if (error)
 166                 goto Finish;
 167
 168         mutex_lock(&pm_mutex);
 169         if (hibernation_mode == HIBERNATION_TESTPROC) {
 170                 printk("swsusp debug: Waiting for 5 seconds.\n");
 171                 mdelay(5000);
 172                 goto Thaw;
 173         }
 174
 175         /* Free memory before shutting down devices. */
 176         error = swsusp_shrink_memory();
 177         if (error)
 178                 goto Thaw;
 179
 180         error = platform_prepare();
 181         if (error)
 182                 goto Thaw;
 183
 184         suspend_console();
 185         error = device_suspend(PMSG_FREEZE);
 186         if (error) {
 187                 printk(KERN_ERR "PM: Some devices failed to suspend\n");
 188                 goto Resume_devices;
 189         }
 190         error = disable_nonboot_cpus();
 191         if (error)
 192                 goto Enable_cpus;
 193
 194         if (hibernation_mode == HIBERNATION_TEST) {
 195                 printk("swsusp debug: Waiting for 5 seconds.\n");
 196                 mdelay(5000);
 197                 goto Enable_cpus;
 198         }
 199
 200         pr_debug("PM: snapshotting memory.\n");
 201         in_suspend = 1;
 202         error = swsusp_suspend();
 203         if (error)
 204                 goto Enable_cpus;
 205
 206         if (in_suspend) {
 207                 enable_nonboot_cpus();
 208                 platform_finish();
 209                 device_resume();
 210                 resume_console();
 211                 pr_debug("PM: writing image.\n");
 212                 error = swsusp_write();
 213                 if (!error)
 214                         power_down();
 215                 else {
 216                         swsusp_free();
 217                         goto Thaw;
 218                 }
 219         } else {
 220                 pr_debug("PM: Image restored successfully.\n");
 221         }
 222
 223         swsusp_free();
 224  Enable_cpus:
 225         enable_nonboot_cpus();
 226  Resume_devices:
 227         platform_finish();
 228         device_resume();
 229         resume_console();
 230  Thaw:
 231         mutex_unlock(&pm_mutex);
 232         unprepare_processes();
 233  Finish:
 234         free_basic_memory_bitmaps();
 235  Exit:
 236         atomic_inc(&snapshot_device_available);
 237         return error;
 238 }
 239
 240
 241 /**
 242  *      software_resume - Resume from a saved image.
 243  *
 244  *      Called as a late_initcall (so all devices are discovered and
 245  *      initialized), we call swsusp to see if we have a saved image or not.
 246  *      If so, we quiesce devices, the restore the saved image. We will
 247  *      return above (in hibernate() ) if everything goes well.
 248  *      Otherwise, we fail gracefully and return to the normally
 249  *      scheduled program.
 250  *
 251  */
 252
 253 static int software_resume(void)
 254 {
 255         int error;
 256
 257         mutex_lock(&pm_mutex);
 258         if (!swsusp_resume_device) {
 259                 if (!strlen(resume_file)) {
 260                         mutex_unlock(&pm_mutex);
 261                         return -ENOENT;
 262                 }
 263                 swsusp_resume_device = name_to_dev_t(resume_file);
 264                 pr_debug("swsusp: Resume From Partition %s\n", resume_file);
 265         } else {
 266                 pr_debug("swsusp: Resume From Partition %d:%d\n",
 267                          MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
 268         }
 269
 270         if (noresume) {
 271                 /**
 272                  * FIXME: If noresume is specified, we need to find the partition
 273                  * and reset it back to normal swap space.
 274                  */
 275                 mutex_unlock(&pm_mutex);
 276                 return 0;
 277         }
 278
 279         pr_debug("PM: Checking swsusp image.\n");
 280         error = swsusp_check();
 281         if (error)
 282                 goto Unlock;
 283
 284         /* The snapshot device should not be opened while we're running */
 285         if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
 286                 error = -EBUSY;
 287                 goto Unlock;
 288         }
 289
 290         error = create_basic_memory_bitmaps();
 291         if (error)
 292                 goto Finish;
 293
 294         pr_debug("PM: Preparing processes for restore.\n");
 295         error = prepare_processes();
 296         if (error) {
 297                 swsusp_close();
 298                 goto Done;
 299         }
 300
 301         pr_debug("PM: Reading swsusp image.\n");
 302
 303         error = swsusp_read();
 304         if (error) {
 305                 swsusp_free();
 306                 goto Thaw;
 307         }
 308
 309         pr_debug("PM: Preparing devices for restore.\n");
 310
 311         suspend_console();
 312         error = device_suspend(PMSG_PRETHAW);
 313         if (error)
 314                 goto Free;
 315
 316         error = disable_nonboot_cpus();
 317         if (!error)
 318                 swsusp_resume();
 319
 320         enable_nonboot_cpus();
 321  Free:
 322         swsusp_free();
 323         device_resume();
 324         resume_console();
 325  Thaw:
 326         printk(KERN_ERR "PM: Restore failed, recovering.\n");
 327         unprepare_processes();
 328  Done:
 329         free_basic_memory_bitmaps();
 330  Finish:
 331         atomic_inc(&snapshot_device_available);
 332         /* For success case, the suspend path will release the lock */
 333  Unlock:
 334         mutex_unlock(&pm_mutex);
 335         pr_debug("PM: Resume from disk failed.\n");
 336         return 0;
 337 }
 338
 339 late_initcall(software_resume);
 340
 341
 342 static const char * const hibernation_modes[] = {
 343         [HIBERNATION_PLATFORM]  = "platform",
 344         [HIBERNATION_SHUTDOWN]  = "shutdown",
 345         [HIBERNATION_REBOOT]    = "reboot",
 346         [HIBERNATION_TEST]      = "test",
 347         [HIBERNATION_TESTPROC]  = "testproc",
 348 };
 349
 350 /**
 351  *      disk - Control hibernation mode
 352  *
 353  *      Suspend-to-disk can be handled in several ways. We have a few options
 354  *      for putting the system to sleep - using the platform driver (e.g. ACPI
 355  *      or other hibernation_ops), powering off the system or rebooting the
 356  *      system (for testing) as well as the two test modes.
 357  *
 358  *      The system can support 'platform', and that is known a priori (and
 359  *      encoded by the presence of hibernation_ops). However, the user may
 360  *      choose 'shutdown' or 'reboot' as alternatives, as well as one fo the
 361  *      test modes, 'test' or 'testproc'.
 362  *
 363  *      show() will display what the mode is currently set to.
 364  *      store() will accept one of
 365  *
 366  *      'platform'
 367  *      'shutdown'
 368  *      'reboot'
 369  *      'test'
 370  *      'testproc'
 371  *
 372  *      It will only change to 'platform' if the system
 373  *      supports it (as determined by having hibernation_ops).
 374  */
 375
 376 static ssize_t disk_show(struct kset *kset, char *buf)
 377 {
 378         int i;
 379         char *start = buf;
 380
 381         for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
 382                 if (!hibernation_modes[i])
 383                         continue;
 384                 switch (i) {
 385                 case HIBERNATION_SHUTDOWN:
 386                 case HIBERNATION_REBOOT:
 387                 case HIBERNATION_TEST:
 388                 case HIBERNATION_TESTPROC:
 389                         break;
 390                 case HIBERNATION_PLATFORM:
 391                         if (hibernation_ops)
 392                                 break;
 393                         /* not a valid mode, continue with loop */
 394                         continue;
 395                 }
 396                 if (i == hibernation_mode)
 397                         buf += sprintf(buf, "[%s] ", hibernation_modes[i]);
 398                 else
 399                         buf += sprintf(buf, "%s ", hibernation_modes[i]);
 400         }
 401         buf += sprintf(buf, "\n");
 402         return buf-start;
 403 }
 404
 405
 406 static ssize_t disk_store(struct kset *kset, const char *buf, size_t n)
 407 {
 408         int error = 0;
 409         int i;
 410         int len;
 411         char *p;
 412         int mode = HIBERNATION_INVALID;
 413
 414         p = memchr(buf, '\n', n);
 415         len = p ? p - buf : n;
 416
 417         mutex_lock(&pm_mutex);
 418         for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
 419                 if (!strncmp(buf, hibernation_modes[i], len)) {
 420                         mode = i;
 421                         break;
 422                 }
 423         }
 424         if (mode != HIBERNATION_INVALID) {
 425                 switch (mode) {
 426                 case HIBERNATION_SHUTDOWN:
 427                 case HIBERNATION_REBOOT:
 428                 case HIBERNATION_TEST:
 429                 case HIBERNATION_TESTPROC:
 430                         hibernation_mode = mode;
 431                         break;
 432                 case HIBERNATION_PLATFORM:
 433                         if (hibernation_ops)
 434                                 hibernation_mode = mode;
 435                         else
 436                                 error = -EINVAL;
 437                 }
 438         } else
 439                 error = -EINVAL;
 440
 441         if (!error)
 442                 pr_debug("PM: suspend-to-disk mode set to '%s'\n",
 443                          hibernation_modes[mode]);
 444         mutex_unlock(&pm_mutex);
 445         return error ? error : n;
 446 }
 447
 448 power_attr(disk);
 449
 450 static ssize_t resume_show(struct kset *kset, char *buf)
 451 {
 452         return sprintf(buf,"%d:%d\n", MAJOR(swsusp_resume_device),
 453                        MINOR(swsusp_resume_device));
 454 }
 455
 456 static ssize_t resume_store(struct kset *kset, const char *buf, size_t n)
 457 {
 458         unsigned int maj, min;
 459         dev_t res;
 460         int ret = -EINVAL;
 461
 462         if (sscanf(buf, "%u:%u", &maj, &min) != 2)
 463                 goto out;
 464
 465         res = MKDEV(maj,min);
 466         if (maj != MAJOR(res) || min != MINOR(res))
 467                 goto out;
 468
 469         mutex_lock(&pm_mutex);
 470         swsusp_resume_device = res;
 471         mutex_unlock(&pm_mutex);
 472         printk("Attempting manual resume\n");
 473         noresume = 0;
 474         software_resume();
 475         ret = n;
 476  out:
 477         return ret;
 478 }
 479
 480 power_attr(resume);
 481
 482 static ssize_t image_size_show(struct kset *kset, char *buf)
 483 {
 484         return sprintf(buf, "%lu\n", image_size);
 485 }
 486
 487 static ssize_t image_size_store(struct kset *kset, const char *buf, size_t n)
 488 {
 489         unsigned long size;
 490
 491         if (sscanf(buf, "%lu", &size) == 1) {
 492                 image_size = size;
 493                 return n;
 494         }
 495
 496         return -EINVAL;
 497 }
 498
 499 power_attr(image_size);
 500
 501 static struct attribute * g[] = {
 502         &disk_attr.attr,
 503         &resume_attr.attr,
 504         &image_size_attr.attr,
 505         NULL,
 506 };
 507
 508
 509 static struct attribute_group attr_group = {
 510         .attrs = g,
 511 };
 512
 513
 514 static int __init pm_disk_init(void)
 515 {
 516         return sysfs_create_group(&power_subsys.kobj, &attr_group);
 517 }
 518
 519 core_initcall(pm_disk_init);
 520
 521
 522 static int __init resume_setup(char *str)
 523 {
 524         if (noresume)
 525                 return 1;
 526
 527         strncpy( resume_file, str, 255 );
 528         return 1;
 529 }
 530
 531 static int __init resume_offset_setup(char *str)
 532 {
 533         unsigned long long offset;
 534
 535         if (noresume)
 536                 return 1;
 537
 538         if (sscanf(str, "%llu", &offset) == 1)
 539                 swsusp_resume_block = offset;
 540
 541         return 1;
 542 }
 543
 544 static int __init noresume_setup(char *str)
 545 {
 546         noresume = 1;
 547         return 1;
 548 }
 549
 550 __setup("noresume", noresume_setup);
 551 __setup("resume_offset=", resume_offset_setup);
 552 __setup("resume=", resume_setup);