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
  22 #include "power.h"
  23
  24
  25 static int noresume = 0;
  26 char resume_file[256] = CONFIG_PM_STD_PARTITION;
  27 dev_t swsusp_resume_device;
  28
  29 /**
  30  *      power_down - Shut machine down for hibernate.
  31  *      @mode:          Suspend-to-disk mode
  32  *
  33  *      Use the platform driver, if configured so, and return gracefully if it
  34  *      fails.
  35  *      Otherwise, try to power off and reboot. If they fail, halt the machine,
  36  *      there ain't no turning back.
  37  */
  38
  39 static void power_down(suspend_disk_method_t mode)
  40 {
  41         int error = 0;
  42
  43         switch(mode) {
  44         case PM_DISK_PLATFORM:
  45                 kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
  46                 error = pm_ops->enter(PM_SUSPEND_DISK);
  47                 break;
  48         case PM_DISK_SHUTDOWN:
  49                 kernel_power_off();
  50                 break;
  51         case PM_DISK_REBOOT:
  52                 kernel_restart(NULL);
  53                 break;
  54         }
  55         kernel_halt();
  56         /* Valid image is on the disk, if we continue we risk serious data corruption
  57            after resume. */
  58         printk(KERN_CRIT "Please power me down manually\n");
  59         while(1);
  60 }
  61
  62 static inline void platform_finish(void)
  63 {
  64         if (pm_disk_mode == PM_DISK_PLATFORM) {
  65                 if (pm_ops && pm_ops->finish)
  66                         pm_ops->finish(PM_SUSPEND_DISK);
  67         }
  68 }
  69
  70 static int prepare_processes(void)
  71 {
  72         int error;
  73
  74         pm_prepare_console();
  75         disable_nonboot_cpus();
  76
  77         if (freeze_processes()) {
  78                 error = -EBUSY;
  79                 goto thaw;
  80         }
  81
  82         /* Free memory before shutting down devices. */
  83         if (!(error = swsusp_shrink_memory()))
  84                 return 0;
  85 thaw:
  86         thaw_processes();
  87         enable_nonboot_cpus();
  88         pm_restore_console();
  89         return error;
  90 }
  91
  92 static void unprepare_processes(void)
  93 {
  94         platform_finish();
  95         thaw_processes();
  96         enable_nonboot_cpus();
  97         pm_restore_console();
  98 }
  99
 100 /**
 101  *      pm_suspend_disk - The granpappy of power management.
 102  *
 103  *      If we're going through the firmware, then get it over with quickly.
 104  *
 105  *      If not, then call swsusp to do its thing, then figure out how
 106  *      to power down the system.
 107  */
 108
 109 int pm_suspend_disk(void)
 110 {
 111         int error;
 112
 113         error = prepare_processes();
 114         if (error)
 115                 return error;
 116
 117         error = device_suspend(PMSG_FREEZE);
 118         if (error) {
 119                 printk("Some devices failed to suspend\n");
 120                 unprepare_processes();
 121                 return error;
 122         }
 123
 124         pr_debug("PM: snapshotting memory.\n");
 125         in_suspend = 1;
 126         if ((error = swsusp_suspend()))
 127                 goto Done;
 128
 129         if (in_suspend) {
 130                 device_resume();
 131                 pr_debug("PM: writing image.\n");
 132                 error = swsusp_write();
 133                 if (!error)
 134                         power_down(pm_disk_mode);
 135                 else {
 136                         swsusp_free();
 137                         unprepare_processes();
 138                         return error;
 139                 }
 140         } else
 141                 pr_debug("PM: Image restored successfully.\n");
 142
 143         swsusp_free();
 144  Done:
 145         device_resume();
 146         unprepare_processes();
 147         return error;
 148 }
 149
 150
 151 /**
 152  *      software_resume - Resume from a saved image.
 153  *
 154  *      Called as a late_initcall (so all devices are discovered and
 155  *      initialized), we call swsusp to see if we have a saved image or not.
 156  *      If so, we quiesce devices, the restore the saved image. We will
 157  *      return above (in pm_suspend_disk() ) if everything goes well.
 158  *      Otherwise, we fail gracefully and return to the normally
 159  *      scheduled program.
 160  *
 161  */
 162
 163 static int software_resume(void)
 164 {
 165         int error;
 166
 167         down(&pm_sem);
 168         if (!swsusp_resume_device) {
 169                 if (!strlen(resume_file)) {
 170                         up(&pm_sem);
 171                         return -ENOENT;
 172                 }
 173                 swsusp_resume_device = name_to_dev_t(resume_file);
 174                 pr_debug("swsusp: Resume From Partition %s\n", resume_file);
 175         } else {
 176                 pr_debug("swsusp: Resume From Partition %d:%d\n",
 177                          MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
 178         }
 179
 180         if (noresume) {
 181                 /**
 182                  * FIXME: If noresume is specified, we need to find the partition
 183                  * and reset it back to normal swap space.
 184                  */
 185                 up(&pm_sem);
 186                 return 0;
 187         }
 188
 189         pr_debug("PM: Checking swsusp image.\n");
 190
 191         if ((error = swsusp_check()))
 192                 goto Done;
 193
 194         pr_debug("PM: Preparing processes for restore.\n");
 195
 196         if ((error = prepare_processes())) {
 197                 swsusp_close();
 198                 goto Done;
 199         }
 200
 201         pr_debug("PM: Reading swsusp image.\n");
 202
 203         if ((error = swsusp_read())) {
 204                 swsusp_free();
 205                 goto Thaw;
 206         }
 207
 208         pr_debug("PM: Preparing devices for restore.\n");
 209
 210         if ((error = device_suspend(PMSG_FREEZE))) {
 211                 printk("Some devices failed to suspend\n");
 212                 swsusp_free();
 213                 goto Thaw;
 214         }
 215
 216         mb();
 217
 218         pr_debug("PM: Restoring saved image.\n");
 219         swsusp_resume();
 220         pr_debug("PM: Restore failed, recovering.n");
 221         device_resume();
 222  Thaw:
 223         unprepare_processes();
 224  Done:
 225         /* For success case, the suspend path will release the lock */
 226         up(&pm_sem);
 227         pr_debug("PM: Resume from disk failed.\n");
 228         return 0;
 229 }
 230
 231 late_initcall(software_resume);
 232
 233
 234 static const char * const pm_disk_modes[] = {
 235         [PM_DISK_FIRMWARE]      = "firmware",
 236         [PM_DISK_PLATFORM]      = "platform",
 237         [PM_DISK_SHUTDOWN]      = "shutdown",
 238         [PM_DISK_REBOOT]        = "reboot",
 239 };
 240
 241 /**
 242  *      disk - Control suspend-to-disk mode
 243  *
 244  *      Suspend-to-disk can be handled in several ways. The greatest
 245  *      distinction is who writes memory to disk - the firmware or the OS.
 246  *      If the firmware does it, we assume that it also handles suspending
 247  *      the system.
 248  *      If the OS does it, then we have three options for putting the system
 249  *      to sleep - using the platform driver (e.g. ACPI or other PM registers),
 250  *      powering off the system or rebooting the system (for testing).
 251  *
 252  *      The system will support either 'firmware' or 'platform', and that is
 253  *      known a priori (and encoded in pm_ops). But, the user may choose
 254  *      'shutdown' or 'reboot' as alternatives.
 255  *
 256  *      show() will display what the mode is currently set to.
 257  *      store() will accept one of
 258  *
 259  *      'firmware'
 260  *      'platform'
 261  *      'shutdown'
 262  *      'reboot'
 263  *
 264  *      It will only change to 'firmware' or 'platform' if the system
 265  *      supports it (as determined from pm_ops->pm_disk_mode).
 266  */
 267
 268 static ssize_t disk_show(struct subsystem * subsys, char * buf)
 269 {
 270         return sprintf(buf, "%s\n", pm_disk_modes[pm_disk_mode]);
 271 }
 272
 273
 274 static ssize_t disk_store(struct subsystem * s, const char * buf, size_t n)
 275 {
 276         int error = 0;
 277         int i;
 278         int len;
 279         char *p;
 280         suspend_disk_method_t mode = 0;
 281
 282         p = memchr(buf, '\n', n);
 283         len = p ? p - buf : n;
 284
 285         down(&pm_sem);
 286         for (i = PM_DISK_FIRMWARE; i < PM_DISK_MAX; i++) {
 287                 if (!strncmp(buf, pm_disk_modes[i], len)) {
 288                         mode = i;
 289                         break;
 290                 }
 291         }
 292         if (mode) {
 293                 if (mode == PM_DISK_SHUTDOWN || mode == PM_DISK_REBOOT)
 294                         pm_disk_mode = mode;
 295                 else {
 296                         if (pm_ops && pm_ops->enter &&
 297                             (mode == pm_ops->pm_disk_mode))
 298                                 pm_disk_mode = mode;
 299                         else
 300                                 error = -EINVAL;
 301                 }
 302         } else
 303                 error = -EINVAL;
 304
 305         pr_debug("PM: suspend-to-disk mode set to '%s'\n",
 306                  pm_disk_modes[mode]);
 307         up(&pm_sem);
 308         return error ? error : n;
 309 }
 310
 311 power_attr(disk);
 312
 313 static ssize_t resume_show(struct subsystem * subsys, char *buf)
 314 {
 315         return sprintf(buf,"%d:%d\n", MAJOR(swsusp_resume_device),
 316                        MINOR(swsusp_resume_device));
 317 }
 318
 319 static ssize_t resume_store(struct subsystem *subsys, const char *buf, size_t n)
 320 {
 321         unsigned int maj, min;
 322         dev_t res;
 323         int ret = -EINVAL;
 324
 325         if (sscanf(buf, "%u:%u", &maj, &min) != 2)
 326                 goto out;
 327
 328         res = MKDEV(maj,min);
 329         if (maj != MAJOR(res) || min != MINOR(res))
 330                 goto out;
 331
 332         down(&pm_sem);
 333         swsusp_resume_device = res;
 334         up(&pm_sem);
 335         printk("Attempting manual resume\n");
 336         noresume = 0;
 337         software_resume();
 338         ret = n;
 339 out:
 340         return ret;
 341 }
 342
 343 power_attr(resume);
 344
 345 static ssize_t image_size_show(struct subsystem * subsys, char *buf)
 346 {
 347         return sprintf(buf, "%lu\n", image_size);
 348 }
 349
 350 static ssize_t image_size_store(struct subsystem * subsys, const char * buf, size_t n)
 351 {
 352         unsigned long size;
 353
 354         if (sscanf(buf, "%lu", &size) == 1) {
 355                 image_size = size;
 356                 return n;
 357         }
 358
 359         return -EINVAL;
 360 }
 361
 362 power_attr(image_size);
 363
 364 static struct attribute * g[] = {
 365         &disk_attr.attr,
 366         &resume_attr.attr,
 367         &image_size_attr.attr,
 368         NULL,
 369 };
 370
 371
 372 static struct attribute_group attr_group = {
 373         .attrs = g,
 374 };
 375
 376
 377 static int __init pm_disk_init(void)
 378 {
 379         return sysfs_create_group(&power_subsys.kset.kobj,&attr_group);
 380 }
 381
 382 core_initcall(pm_disk_init);
 383
 384
 385 static int __init resume_setup(char *str)
 386 {
 387         if (noresume)
 388                 return 1;
 389
 390         strncpy( resume_file, str, 255 );
 391         return 1;
 392 }
 393
 394 static int __init noresume_setup(char *str)
 395 {
 396         noresume = 1;
 397         return 1;
 398 }
 399
 400 __setup("noresume", noresume_setup);
 401 __setup("resume=", resume_setup);