git.oblomov.eu Git - linux-2.6/blob - 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 (len == strlen(hibernation_modes[i])
 420                     && !strncmp(buf, hibernation_modes[i], len)) {
 421                         mode = i;
 422                         break;
 423                 }
 424         }
 425         if (mode != HIBERNATION_INVALID) {
 426                 switch (mode) {
 427                 case HIBERNATION_SHUTDOWN:
 428                 case HIBERNATION_REBOOT:
 429                 case HIBERNATION_TEST:
 430                 case HIBERNATION_TESTPROC:
 431                         hibernation_mode = mode;
 432                         break;
 433                 case HIBERNATION_PLATFORM:
 434                         if (hibernation_ops)
 435                                 hibernation_mode = mode;
 436                         else
 437                                 error = -EINVAL;
 438                 }
 439         } else
 440                 error = -EINVAL;
 441
 442         if (!error)
 443                 pr_debug("PM: suspend-to-disk mode set to '%s'\n",
 444                          hibernation_modes[mode]);
 445         mutex_unlock(&pm_mutex);
 446         return error ? error : n;
 447 }
 448
 449 power_attr(disk);
 450
 451 static ssize_t resume_show(struct kset *kset, char *buf)
 452 {
 453         return sprintf(buf,"%d:%d\n", MAJOR(swsusp_resume_device),
 454                        MINOR(swsusp_resume_device));
 455 }
 456
 457 static ssize_t resume_store(struct kset *kset, const char *buf, size_t n)
 458 {
 459         unsigned int maj, min;
 460         dev_t res;
 461         int ret = -EINVAL;
 462
 463         if (sscanf(buf, "%u:%u", &maj, &min) != 2)
 464                 goto out;
 465
 466         res = MKDEV(maj,min);
 467         if (maj != MAJOR(res) || min != MINOR(res))
 468                 goto out;
 469
 470         mutex_lock(&pm_mutex);
 471         swsusp_resume_device = res;
 472         mutex_unlock(&pm_mutex);
 473         printk("Attempting manual resume\n");
 474         noresume = 0;
 475         software_resume();
 476         ret = n;
 477  out:
 478         return ret;
 479 }
 480
 481 power_attr(resume);
 482
 483 static ssize_t image_size_show(struct kset *kset, char *buf)
 484 {
 485         return sprintf(buf, "%lu\n", image_size);
 486 }
 487
 488 static ssize_t image_size_store(struct kset *kset, const char *buf, size_t n)
 489 {
 490         unsigned long size;
 491
 492         if (sscanf(buf, "%lu", &size) == 1) {
 493                 image_size = size;
 494                 return n;
 495         }
 496
 497         return -EINVAL;
 498 }
 499
 500 power_attr(image_size);
 501
 502 static struct attribute * g[] = {
 503         &disk_attr.attr,
 504         &resume_attr.attr,
 505         &image_size_attr.attr,
 506         NULL,
 507 };
 508
 509
 510 static struct attribute_group attr_group = {
 511         .attrs = g,
 512 };
 513
 514
 515 static int __init pm_disk_init(void)
 516 {
 517         return sysfs_create_group(&power_subsys.kobj, &attr_group);
 518 }
 519
 520 core_initcall(pm_disk_init);
 521
 522
 523 static int __init resume_setup(char *str)
 524 {
 525         if (noresume)
 526                 return 1;
 527
 528         strncpy( resume_file, str, 255 );
 529         return 1;
 530 }
 531
 532 static int __init resume_offset_setup(char *str)
 533 {
 534         unsigned long long offset;
 535
 536         if (noresume)
 537                 return 1;
 538
 539         if (sscanf(str, "%llu", &offset) == 1)
 540                 swsusp_resume_block = offset;
 541
 542         return 1;
 543 }
 544
 545 static int __init noresume_setup(char *str)
 546 {
 547         noresume = 1;
 548         return 1;
 549 }
 550
 551 __setup("noresume", noresume_setup);
 552 __setup("resume_offset=", resume_offset_setup);
 553 __setup("resume=", resume_setup);