kernel/power/main.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * kernel/power/main.c - PM subsystem core functionality.
   4  *
   5  * Copyright (c) 2003 Patrick Mochel
   6  * Copyright (c) 2003 Open Source Development Lab
   7  */
   8
   9 #include <linux/export.h>
  10 #include <linux/kobject.h>
  11 #include <linux/string.h>
  12 #include <linux/pm-trace.h>
  13 #include <linux/workqueue.h>
  14 #include <linux/debugfs.h>
  15 #include <linux/seq_file.h>
  16 #include <linux/suspend.h>
  17 #include <linux/syscalls.h>
  18 #include <linux/pm_runtime.h>
  19
  20 #include "power.h"
  21
  22 #ifdef CONFIG_PM_SLEEP
  23
  24 void lock_system_sleep(void)
  25 {
  26         current->flags |= PF_FREEZER_SKIP;
  27         mutex_lock(&system_transition_mutex);
  28 }
  29 EXPORT_SYMBOL_GPL(lock_system_sleep);
  30
  31 void unlock_system_sleep(void)
  32 {
  33         /*
  34          * Don't use freezer_count() because we don't want the call to
  35          * try_to_freeze() here.
  36          *
  37          * Reason:
  38          * Fundamentally, we just don't need it, because freezing condition
  39          * doesn't come into effect until we release the
  40          * system_transition_mutex lock, since the freezer always works with
  41          * system_transition_mutex held.
  42          *
  43          * More importantly, in the case of hibernation,
  44          * unlock_system_sleep() gets called in snapshot_read() and
  45          * snapshot_write() when the freezing condition is still in effect.
  46          * Which means, if we use try_to_freeze() here, it would make them
  47          * enter the refrigerator, thus causing hibernation to lockup.
  48          */
  49         current->flags &= ~PF_FREEZER_SKIP;
  50         mutex_unlock(&system_transition_mutex);
  51 }
  52 EXPORT_SYMBOL_GPL(unlock_system_sleep);
  53
  54 void ksys_sync_helper(void)
  55 {
  56         ktime_t start;
  57         long elapsed_msecs;
  58
  59         start = ktime_get();
  60         ksys_sync();
  61         elapsed_msecs = ktime_to_ms(ktime_sub(ktime_get(), start));
  62         pr_info("Filesystems sync: %ld.%03ld seconds\n",
  63                 elapsed_msecs / MSEC_PER_SEC, elapsed_msecs % MSEC_PER_SEC);
  64 }
  65 EXPORT_SYMBOL_GPL(ksys_sync_helper);
  66
  67 /* Routines for PM-transition notifications */
  68
  69 static BLOCKING_NOTIFIER_HEAD(pm_chain_head);
  70
  71 int register_pm_notifier(struct notifier_block *nb)
  72 {
  73         return blocking_notifier_chain_register(&pm_chain_head, nb);
  74 }
  75 EXPORT_SYMBOL_GPL(register_pm_notifier);
  76
  77 int unregister_pm_notifier(struct notifier_block *nb)
  78 {
  79         return blocking_notifier_chain_unregister(&pm_chain_head, nb);
  80 }
  81 EXPORT_SYMBOL_GPL(unregister_pm_notifier);
  82
  83 int pm_notifier_call_chain_robust(unsigned long val_up, unsigned long val_down)
  84 {
  85         int ret;
  86
  87         ret = blocking_notifier_call_chain_robust(&pm_chain_head, val_up, val_down, NULL);
  88
  89         return notifier_to_errno(ret);
  90 }
  91
  92 int pm_notifier_call_chain(unsigned long val)
  93 {
  94         return blocking_notifier_call_chain(&pm_chain_head, val, NULL);
  95 }
  96
  97 /* If set, devices may be suspended and resumed asynchronously. */
  98 int pm_async_enabled = 1;
  99
 100 static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr,
 101                              char *buf)
 102 {
 103         return sprintf(buf, "%d\n", pm_async_enabled);
 104 }
 105
 106 static ssize_t pm_async_store(struct kobject *kobj, struct kobj_attribute *attr,
 107                               const char *buf, size_t n)
 108 {
 109         unsigned long val;
 110
 111         if (kstrtoul(buf, 10, &val))
 112                 return -EINVAL;
 113
 114         if (val > 1)
 115                 return -EINVAL;
 116
 117         pm_async_enabled = val;
 118         return n;
 119 }
 120
 121 power_attr(pm_async);
 122
 123 #ifdef CONFIG_SUSPEND
 124 static ssize_t mem_sleep_show(struct kobject *kobj, struct kobj_attribute *attr,
 125                               char *buf)
 126 {
 127         char *s = buf;
 128         suspend_state_t i;
 129
 130         for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++)
 131                 if (mem_sleep_states[i]) {
 132                         const char *label = mem_sleep_states[i];
 133
 134                         if (mem_sleep_current == i)
 135                                 s += sprintf(s, "[%s] ", label);
 136                         else
 137                                 s += sprintf(s, "%s ", label);
 138                 }
 139
 140         /* Convert the last space to a newline if needed. */
 141         if (s != buf)
 142                 *(s-1) = '\n';
 143
 144         return (s - buf);
 145 }
 146
 147 static suspend_state_t decode_suspend_state(const char *buf, size_t n)
 148 {
 149         suspend_state_t state;
 150         char *p;
 151         int len;
 152
 153         p = memchr(buf, '\n', n);
 154         len = p ? p - buf : n;
 155
 156         for (state = PM_SUSPEND_MIN; state < PM_SUSPEND_MAX; state++) {
 157                 const char *label = mem_sleep_states[state];
 158
 159                 if (label && len == strlen(label) && !strncmp(buf, label, len))
 160                         return state;
 161         }
 162
 163         return PM_SUSPEND_ON;
 164 }
 165
 166 static ssize_t mem_sleep_store(struct kobject *kobj, struct kobj_attribute *attr,
 167                                const char *buf, size_t n)
 168 {
 169         suspend_state_t state;
 170         int error;
 171
 172         error = pm_autosleep_lock();
 173         if (error)
 174                 return error;
 175
 176         if (pm_autosleep_state() > PM_SUSPEND_ON) {
 177                 error = -EBUSY;
 178                 goto out;
 179         }
 180
 181         state = decode_suspend_state(buf, n);
 182         if (state < PM_SUSPEND_MAX && state > PM_SUSPEND_ON)
 183                 mem_sleep_current = state;
 184         else
 185                 error = -EINVAL;
 186
 187  out:
 188         pm_autosleep_unlock();
 189         return error ? error : n;
 190 }
 191
 192 power_attr(mem_sleep);
 193
 194 /*
 195  * sync_on_suspend: invoke ksys_sync_helper() before suspend.
 196  *
 197  * show() returns whether ksys_sync_helper() is invoked before suspend.
 198  * store() accepts 0 or 1.  0 disables ksys_sync_helper() and 1 enables it.
 199  */
 200 bool sync_on_suspend_enabled = !IS_ENABLED(CONFIG_SUSPEND_SKIP_SYNC);
 201
 202 static ssize_t sync_on_suspend_show(struct kobject *kobj,
 203                                    struct kobj_attribute *attr, char *buf)
 204 {
 205         return sprintf(buf, "%d\n", sync_on_suspend_enabled);
 206 }
 207
 208 static ssize_t sync_on_suspend_store(struct kobject *kobj,
 209                                     struct kobj_attribute *attr,
 210                                     const char *buf, size_t n)
 211 {
 212         unsigned long val;
 213
 214         if (kstrtoul(buf, 10, &val))
 215                 return -EINVAL;
 216
 217         if (val > 1)
 218                 return -EINVAL;
 219
 220         sync_on_suspend_enabled = !!val;
 221         return n;
 222 }
 223
 224 power_attr(sync_on_suspend);
 225 #endif /* CONFIG_SUSPEND */
 226
 227 #ifdef CONFIG_PM_SLEEP_DEBUG
 228 int pm_test_level = TEST_NONE;
 229
 230 static const char * const pm_tests[__TEST_AFTER_LAST] = {
 231         [TEST_NONE] = "none",
 232         [TEST_CORE] = "core",
 233         [TEST_CPUS] = "processors",
 234         [TEST_PLATFORM] = "platform",
 235         [TEST_DEVICES] = "devices",
 236         [TEST_FREEZER] = "freezer",
 237 };
 238
 239 static ssize_t pm_test_show(struct kobject *kobj, struct kobj_attribute *attr,
 240                                 char *buf)
 241 {
 242         char *s = buf;
 243         int level;
 244
 245         for (level = TEST_FIRST; level <= TEST_MAX; level++)
 246                 if (pm_tests[level]) {
 247                         if (level == pm_test_level)
 248                                 s += sprintf(s, "[%s] ", pm_tests[level]);
 249                         else
 250                                 s += sprintf(s, "%s ", pm_tests[level]);
 251                 }
 252
 253         if (s != buf)
 254                 /* convert the last space to a newline */
 255                 *(s-1) = '\n';
 256
 257         return (s - buf);
 258 }
 259
 260 static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
 261                                 const char *buf, size_t n)
 262 {
 263         const char * const *s;
 264         int level;
 265         char *p;
 266         int len;
 267         int error = -EINVAL;
 268
 269         p = memchr(buf, '\n', n);
 270         len = p ? p - buf : n;
 271
 272         lock_system_sleep();
 273
 274         level = TEST_FIRST;
 275         for (s = &pm_tests[level]; level <= TEST_MAX; s++, level++)
 276                 if (*s && len == strlen(*s) && !strncmp(buf, *s, len)) {
 277                         pm_test_level = level;
 278                         error = 0;
 279                         break;
 280                 }
 281
 282         unlock_system_sleep();
 283
 284         return error ? error : n;
 285 }
 286
 287 power_attr(pm_test);
 288 #endif /* CONFIG_PM_SLEEP_DEBUG */
 289
 290 static char *suspend_step_name(enum suspend_stat_step step)
 291 {
 292         switch (step) {
 293         case SUSPEND_FREEZE:
 294                 return "freeze";
 295         case SUSPEND_PREPARE:
 296                 return "prepare";
 297         case SUSPEND_SUSPEND:
 298                 return "suspend";
 299         case SUSPEND_SUSPEND_NOIRQ:
 300                 return "suspend_noirq";
 301         case SUSPEND_RESUME_NOIRQ:
 302                 return "resume_noirq";
 303         case SUSPEND_RESUME:
 304                 return "resume";
 305         default:
 306                 return "";
 307         }
 308 }
 309
 310 #define suspend_attr(_name)                                     \
 311 static ssize_t _name##_show(struct kobject *kobj,               \
 312                 struct kobj_attribute *attr, char *buf)         \
 313 {                                                               \
 314         return sprintf(buf, "%d\n", suspend_stats._name);       \
 315 }                                                               \
 316 static struct kobj_attribute _name = __ATTR_RO(_name)
 317
 318 suspend_attr(success);
 319 suspend_attr(fail);
 320 suspend_attr(failed_freeze);
 321 suspend_attr(failed_prepare);
 322 suspend_attr(failed_suspend);
 323 suspend_attr(failed_suspend_late);
 324 suspend_attr(failed_suspend_noirq);
 325 suspend_attr(failed_resume);
 326 suspend_attr(failed_resume_early);
 327 suspend_attr(failed_resume_noirq);
 328
 329 static ssize_t last_failed_dev_show(struct kobject *kobj,
 330                 struct kobj_attribute *attr, char *buf)
 331 {
 332         int index;
 333         char *last_failed_dev = NULL;
 334
 335         index = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
 336         index %= REC_FAILED_NUM;
 337         last_failed_dev = suspend_stats.failed_devs[index];
 338
 339         return sprintf(buf, "%s\n", last_failed_dev);
 340 }
 341 static struct kobj_attribute last_failed_dev = __ATTR_RO(last_failed_dev);
 342
 343 static ssize_t last_failed_errno_show(struct kobject *kobj,
 344                 struct kobj_attribute *attr, char *buf)
 345 {
 346         int index;
 347         int last_failed_errno;
 348
 349         index = suspend_stats.last_failed_errno + REC_FAILED_NUM - 1;
 350         index %= REC_FAILED_NUM;
 351         last_failed_errno = suspend_stats.errno[index];
 352
 353         return sprintf(buf, "%d\n", last_failed_errno);
 354 }
 355 static struct kobj_attribute last_failed_errno = __ATTR_RO(last_failed_errno);
 356
 357 static ssize_t last_failed_step_show(struct kobject *kobj,
 358                 struct kobj_attribute *attr, char *buf)
 359 {
 360         int index;
 361         enum suspend_stat_step step;
 362         char *last_failed_step = NULL;
 363
 364         index = suspend_stats.last_failed_step + REC_FAILED_NUM - 1;
 365         index %= REC_FAILED_NUM;
 366         step = suspend_stats.failed_steps[index];
 367         last_failed_step = suspend_step_name(step);
 368
 369         return sprintf(buf, "%s\n", last_failed_step);
 370 }
 371 static struct kobj_attribute last_failed_step = __ATTR_RO(last_failed_step);
 372
 373 static struct attribute *suspend_attrs[] = {
 374         &success.attr,
 375         &fail.attr,
 376         &failed_freeze.attr,
 377         &failed_prepare.attr,
 378         &failed_suspend.attr,
 379         &failed_suspend_late.attr,
 380         &failed_suspend_noirq.attr,
 381         &failed_resume.attr,
 382         &failed_resume_early.attr,
 383         &failed_resume_noirq.attr,
 384         &last_failed_dev.attr,
 385         &last_failed_errno.attr,
 386         &last_failed_step.attr,
 387         NULL,
 388 };
 389
 390 static struct attribute_group suspend_attr_group = {
 391         .name = "suspend_stats",
 392         .attrs = suspend_attrs,
 393 };
 394
 395 #ifdef CONFIG_DEBUG_FS
 396 static int suspend_stats_show(struct seq_file *s, void *unused)
 397 {
 398         int i, index, last_dev, last_errno, last_step;
 399
 400         last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
 401         last_dev %= REC_FAILED_NUM;
 402         last_errno = suspend_stats.last_failed_errno + REC_FAILED_NUM - 1;
 403         last_errno %= REC_FAILED_NUM;
 404         last_step = suspend_stats.last_failed_step + REC_FAILED_NUM - 1;
 405         last_step %= REC_FAILED_NUM;
 406         seq_printf(s, "%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n"
 407                         "%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n",
 408                         "success", suspend_stats.success,
 409                         "fail", suspend_stats.fail,
 410                         "failed_freeze", suspend_stats.failed_freeze,
 411                         "failed_prepare", suspend_stats.failed_prepare,
 412                         "failed_suspend", suspend_stats.failed_suspend,
 413                         "failed_suspend_late",
 414                                 suspend_stats.failed_suspend_late,
 415                         "failed_suspend_noirq",
 416                                 suspend_stats.failed_suspend_noirq,
 417                         "failed_resume", suspend_stats.failed_resume,
 418                         "failed_resume_early",
 419                                 suspend_stats.failed_resume_early,
 420                         "failed_resume_noirq",
 421                                 suspend_stats.failed_resume_noirq);
 422         seq_printf(s,   "failures:\n  last_failed_dev:\t%-s\n",
 423                         suspend_stats.failed_devs[last_dev]);
 424         for (i = 1; i < REC_FAILED_NUM; i++) {
 425                 index = last_dev + REC_FAILED_NUM - i;
 426                 index %= REC_FAILED_NUM;
 427                 seq_printf(s, "\t\t\t%-s\n",
 428                         suspend_stats.failed_devs[index]);
 429         }
 430         seq_printf(s,   "  last_failed_errno:\t%-d\n",
 431                         suspend_stats.errno[last_errno]);
 432         for (i = 1; i < REC_FAILED_NUM; i++) {
 433                 index = last_errno + REC_FAILED_NUM - i;
 434                 index %= REC_FAILED_NUM;
 435                 seq_printf(s, "\t\t\t%-d\n",
 436                         suspend_stats.errno[index]);
 437         }
 438         seq_printf(s,   "  last_failed_step:\t%-s\n",
 439                         suspend_step_name(
 440                                 suspend_stats.failed_steps[last_step]));
 441         for (i = 1; i < REC_FAILED_NUM; i++) {
 442                 index = last_step + REC_FAILED_NUM - i;
 443                 index %= REC_FAILED_NUM;
 444                 seq_printf(s, "\t\t\t%-s\n",
 445                         suspend_step_name(
 446                                 suspend_stats.failed_steps[index]));
 447         }
 448
 449         return 0;
 450 }
 451 DEFINE_SHOW_ATTRIBUTE(suspend_stats);
 452
 453 static int __init pm_debugfs_init(void)
 454 {
 455         debugfs_create_file("suspend_stats", S_IFREG | S_IRUGO,
 456                         NULL, NULL, &suspend_stats_fops);
 457         return 0;
 458 }
 459
 460 late_initcall(pm_debugfs_init);
 461 #endif /* CONFIG_DEBUG_FS */
 462
 463 #endif /* CONFIG_PM_SLEEP */
 464
 465 #ifdef CONFIG_PM_SLEEP_DEBUG
 466 /*
 467  * pm_print_times: print time taken by devices to suspend and resume.
 468  *
 469  * show() returns whether printing of suspend and resume times is enabled.
 470  * store() accepts 0 or 1.  0 disables printing and 1 enables it.
 471  */
 472 bool pm_print_times_enabled;
 473
 474 static ssize_t pm_print_times_show(struct kobject *kobj,
 475                                    struct kobj_attribute *attr, char *buf)
 476 {
 477         return sprintf(buf, "%d\n", pm_print_times_enabled);
 478 }
 479
 480 static ssize_t pm_print_times_store(struct kobject *kobj,
 481                                     struct kobj_attribute *attr,
 482                                     const char *buf, size_t n)
 483 {
 484         unsigned long val;
 485
 486         if (kstrtoul(buf, 10, &val))
 487                 return -EINVAL;
 488
 489         if (val > 1)
 490                 return -EINVAL;
 491
 492         pm_print_times_enabled = !!val;
 493         return n;
 494 }
 495
 496 power_attr(pm_print_times);
 497
 498 static inline void pm_print_times_init(void)
 499 {
 500         pm_print_times_enabled = !!initcall_debug;
 501 }
 502
 503 static ssize_t pm_wakeup_irq_show(struct kobject *kobj,
 504                                         struct kobj_attribute *attr,
 505                                         char *buf)
 506 {
 507         if (!pm_wakeup_irq())
 508                 return -ENODATA;
 509
 510         return sprintf(buf, "%u\n", pm_wakeup_irq());
 511 }
 512
 513 power_attr_ro(pm_wakeup_irq);
 514
 515 bool pm_debug_messages_on __read_mostly;
 516
 517 static ssize_t pm_debug_messages_show(struct kobject *kobj,
 518                                       struct kobj_attribute *attr, char *buf)
 519 {
 520         return sprintf(buf, "%d\n", pm_debug_messages_on);
 521 }
 522
 523 static ssize_t pm_debug_messages_store(struct kobject *kobj,
 524                                        struct kobj_attribute *attr,
 525                                        const char *buf, size_t n)
 526 {
 527         unsigned long val;
 528
 529         if (kstrtoul(buf, 10, &val))
 530                 return -EINVAL;
 531
 532         if (val > 1)
 533                 return -EINVAL;
 534
 535         pm_debug_messages_on = !!val;
 536         return n;
 537 }
 538
 539 power_attr(pm_debug_messages);
 540
 541 static int __init pm_debug_messages_setup(char *str)
 542 {
 543         pm_debug_messages_on = true;
 544         return 1;
 545 }
 546 __setup("pm_debug_messages", pm_debug_messages_setup);
 547
 548 /**
 549  * __pm_pr_dbg - Print a suspend debug message to the kernel log.
 550  * @defer: Whether or not to use printk_deferred() to print the message.
 551  * @fmt: Message format.
 552  *
 553  * The message will be emitted if enabled through the pm_debug_messages
 554  * sysfs attribute.
 555  */
 556 void __pm_pr_dbg(bool defer, const char *fmt, ...)
 557 {
 558         struct va_format vaf;
 559         va_list args;
 560
 561         if (!pm_debug_messages_on)
 562                 return;
 563
 564         va_start(args, fmt);
 565
 566         vaf.fmt = fmt;
 567         vaf.va = &args;
 568
 569         if (defer)
 570                 printk_deferred(KERN_DEBUG "PM: %pV", &vaf);
 571         else
 572                 printk(KERN_DEBUG "PM: %pV", &vaf);
 573
 574         va_end(args);
 575 }
 576
 577 #else /* !CONFIG_PM_SLEEP_DEBUG */
 578 static inline void pm_print_times_init(void) {}
 579 #endif /* CONFIG_PM_SLEEP_DEBUG */
 580
 581 struct kobject *power_kobj;
 582
 583 /**
 584  * state - control system sleep states.
 585  *
 586  * show() returns available sleep state labels, which may be "mem", "standby",
 587  * "freeze" and "disk" (hibernation).
 588  * See Documentation/admin-guide/pm/sleep-states.rst for a description of
 589  * what they mean.
 590  *
 591  * store() accepts one of those strings, translates it into the proper
 592  * enumerated value, and initiates a suspend transition.
 593  */
 594 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
 595                           char *buf)
 596 {
 597         char *s = buf;
 598 #ifdef CONFIG_SUSPEND
 599         suspend_state_t i;
 600
 601         for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++)
 602                 if (pm_states[i])
 603                         s += sprintf(s,"%s ", pm_states[i]);
 604
 605 #endif
 606         if (hibernation_available())
 607                 s += sprintf(s, "disk ");
 608         if (s != buf)
 609                 /* convert the last space to a newline */
 610                 *(s-1) = '\n';
 611         return (s - buf);
 612 }
 613
 614 static suspend_state_t decode_state(const char *buf, size_t n)
 615 {
 616 #ifdef CONFIG_SUSPEND
 617         suspend_state_t state;
 618 #endif
 619         char *p;
 620         int len;
 621
 622         p = memchr(buf, '\n', n);
 623         len = p ? p - buf : n;
 624
 625         /* Check hibernation first. */
 626         if (len == 4 && str_has_prefix(buf, "disk"))
 627                 return PM_SUSPEND_MAX;
 628
 629 #ifdef CONFIG_SUSPEND
 630         for (state = PM_SUSPEND_MIN; state < PM_SUSPEND_MAX; state++) {
 631                 const char *label = pm_states[state];
 632
 633                 if (label && len == strlen(label) && !strncmp(buf, label, len))
 634                         return state;
 635         }
 636 #endif
 637
 638         return PM_SUSPEND_ON;
 639 }
 640
 641 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
 642                            const char *buf, size_t n)
 643 {
 644         suspend_state_t state;
 645         int error;
 646
 647         error = pm_autosleep_lock();
 648         if (error)
 649                 return error;
 650
 651         if (pm_autosleep_state() > PM_SUSPEND_ON) {
 652                 error = -EBUSY;
 653                 goto out;
 654         }
 655
 656         state = decode_state(buf, n);
 657         if (state < PM_SUSPEND_MAX) {
 658                 if (state == PM_SUSPEND_MEM)
 659                         state = mem_sleep_current;
 660
 661                 error = pm_suspend(state);
 662         } else if (state == PM_SUSPEND_MAX) {
 663                 error = hibernate();
 664         } else {
 665                 error = -EINVAL;
 666         }
 667
 668  out:
 669         pm_autosleep_unlock();
 670         return error ? error : n;
 671 }
 672
 673 power_attr(state);
 674
 675 #ifdef CONFIG_PM_SLEEP
 676 /*
 677  * The 'wakeup_count' attribute, along with the functions defined in
 678  * drivers/base/power/wakeup.c, provides a means by which wakeup events can be
 679  * handled in a non-racy way.
 680  *
 681  * If a wakeup event occurs when the system is in a sleep state, it simply is
 682  * woken up.  In turn, if an event that would wake the system up from a sleep
 683  * state occurs when it is undergoing a transition to that sleep state, the
 684  * transition should be aborted.  Moreover, if such an event occurs when the
 685  * system is in the working state, an attempt to start a transition to the
 686  * given sleep state should fail during certain period after the detection of
 687  * the event.  Using the 'state' attribute alone is not sufficient to satisfy
 688  * these requirements, because a wakeup event may occur exactly when 'state'
 689  * is being written to and may be delivered to user space right before it is
 690  * frozen, so the event will remain only partially processed until the system is
 691  * woken up by another event.  In particular, it won't cause the transition to
 692  * a sleep state to be aborted.
 693  *
 694  * This difficulty may be overcome if user space uses 'wakeup_count' before
 695  * writing to 'state'.  It first should read from 'wakeup_count' and store
 696  * the read value.  Then, after carrying out its own preparations for the system
 697  * transition to a sleep state, it should write the stored value to
 698  * 'wakeup_count'.  If that fails, at least one wakeup event has occurred since
 699  * 'wakeup_count' was read and 'state' should not be written to.  Otherwise, it
 700  * is allowed to write to 'state', but the transition will be aborted if there
 701  * are any wakeup events detected after 'wakeup_count' was written to.
 702  */
 703
 704 static ssize_t wakeup_count_show(struct kobject *kobj,
 705                                 struct kobj_attribute *attr,
 706                                 char *buf)
 707 {
 708         unsigned int val;
 709
 710         return pm_get_wakeup_count(&val, true) ?
 711                 sprintf(buf, "%u\n", val) : -EINTR;
 712 }
 713
 714 static ssize_t wakeup_count_store(struct kobject *kobj,
 715                                 struct kobj_attribute *attr,
 716                                 const char *buf, size_t n)
 717 {
 718         unsigned int val;
 719         int error;
 720
 721         error = pm_autosleep_lock();
 722         if (error)
 723                 return error;
 724
 725         if (pm_autosleep_state() > PM_SUSPEND_ON) {
 726                 error = -EBUSY;
 727                 goto out;
 728         }
 729
 730         error = -EINVAL;
 731         if (sscanf(buf, "%u", &val) == 1) {
 732                 if (pm_save_wakeup_count(val))
 733                         error = n;
 734                 else
 735                         pm_print_active_wakeup_sources();
 736         }
 737
 738  out:
 739         pm_autosleep_unlock();
 740         return error;
 741 }
 742
 743 power_attr(wakeup_count);
 744
 745 #ifdef CONFIG_PM_AUTOSLEEP
 746 static ssize_t autosleep_show(struct kobject *kobj,
 747                               struct kobj_attribute *attr,
 748                               char *buf)
 749 {
 750         suspend_state_t state = pm_autosleep_state();
 751
 752         if (state == PM_SUSPEND_ON)
 753                 return sprintf(buf, "off\n");
 754
 755 #ifdef CONFIG_SUSPEND
 756         if (state < PM_SUSPEND_MAX)
 757                 return sprintf(buf, "%s\n", pm_states[state] ?
 758                                         pm_states[state] : "error");
 759 #endif
 760 #ifdef CONFIG_HIBERNATION
 761         return sprintf(buf, "disk\n");
 762 #else
 763         return sprintf(buf, "error");
 764 #endif
 765 }
 766
 767 static ssize_t autosleep_store(struct kobject *kobj,
 768                                struct kobj_attribute *attr,
 769                                const char *buf, size_t n)
 770 {
 771         suspend_state_t state = decode_state(buf, n);
 772         int error;
 773
 774         if (state == PM_SUSPEND_ON
 775             && strcmp(buf, "off") && strcmp(buf, "off\n"))
 776                 return -EINVAL;
 777
 778         if (state == PM_SUSPEND_MEM)
 779                 state = mem_sleep_current;
 780
 781         error = pm_autosleep_set_state(state);
 782         return error ? error : n;
 783 }
 784
 785 power_attr(autosleep);
 786 #endif /* CONFIG_PM_AUTOSLEEP */
 787
 788 #ifdef CONFIG_PM_WAKELOCKS
 789 static ssize_t wake_lock_show(struct kobject *kobj,
 790                               struct kobj_attribute *attr,
 791                               char *buf)
 792 {
 793         return pm_show_wakelocks(buf, true);
 794 }
 795
 796 static ssize_t wake_lock_store(struct kobject *kobj,
 797                                struct kobj_attribute *attr,
 798                                const char *buf, size_t n)
 799 {
 800         int error = pm_wake_lock(buf);
 801         return error ? error : n;
 802 }
 803
 804 power_attr(wake_lock);
 805
 806 static ssize_t wake_unlock_show(struct kobject *kobj,
 807                                 struct kobj_attribute *attr,
 808                                 char *buf)
 809 {
 810         return pm_show_wakelocks(buf, false);
 811 }
 812
 813 static ssize_t wake_unlock_store(struct kobject *kobj,
 814                                  struct kobj_attribute *attr,
 815                                  const char *buf, size_t n)
 816 {
 817         int error = pm_wake_unlock(buf);
 818         return error ? error : n;
 819 }
 820
 821 power_attr(wake_unlock);
 822
 823 #endif /* CONFIG_PM_WAKELOCKS */
 824 #endif /* CONFIG_PM_SLEEP */
 825
 826 #ifdef CONFIG_PM_TRACE
 827 int pm_trace_enabled;
 828
 829 static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
 830                              char *buf)
 831 {
 832         return sprintf(buf, "%d\n", pm_trace_enabled);
 833 }
 834
 835 static ssize_t
 836 pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
 837                const char *buf, size_t n)
 838 {
 839         int val;
 840
 841         if (sscanf(buf, "%d", &val) == 1) {
 842                 pm_trace_enabled = !!val;
 843                 if (pm_trace_enabled) {
 844                         pr_warn("PM: Enabling pm_trace changes system date and time during resume.\n"
 845                                 "PM: Correct system time has to be restored manually after resume.\n");
 846                 }
 847                 return n;
 848         }
 849         return -EINVAL;
 850 }
 851
 852 power_attr(pm_trace);
 853
 854 static ssize_t pm_trace_dev_match_show(struct kobject *kobj,
 855                                        struct kobj_attribute *attr,
 856                                        char *buf)
 857 {
 858         return show_trace_dev_match(buf, PAGE_SIZE);
 859 }
 860
 861 power_attr_ro(pm_trace_dev_match);
 862
 863 #endif /* CONFIG_PM_TRACE */
 864
 865 #ifdef CONFIG_FREEZER
 866 static ssize_t pm_freeze_timeout_show(struct kobject *kobj,
 867                                       struct kobj_attribute *attr, char *buf)
 868 {
 869         return sprintf(buf, "%u\n", freeze_timeout_msecs);
 870 }
 871
 872 static ssize_t pm_freeze_timeout_store(struct kobject *kobj,
 873                                        struct kobj_attribute *attr,
 874                                        const char *buf, size_t n)
 875 {
 876         unsigned long val;
 877
 878         if (kstrtoul(buf, 10, &val))
 879                 return -EINVAL;
 880
 881         freeze_timeout_msecs = val;
 882         return n;
 883 }
 884
 885 power_attr(pm_freeze_timeout);
 886
 887 #endif  /* CONFIG_FREEZER*/
 888
 889 static struct attribute * g[] = {
 890         &state_attr.attr,
 891 #ifdef CONFIG_PM_TRACE
 892         &pm_trace_attr.attr,
 893         &pm_trace_dev_match_attr.attr,
 894 #endif
 895 #ifdef CONFIG_PM_SLEEP
 896         &pm_async_attr.attr,
 897         &wakeup_count_attr.attr,
 898 #ifdef CONFIG_SUSPEND
 899         &mem_sleep_attr.attr,
 900         &sync_on_suspend_attr.attr,
 901 #endif
 902 #ifdef CONFIG_PM_AUTOSLEEP
 903         &autosleep_attr.attr,
 904 #endif
 905 #ifdef CONFIG_PM_WAKELOCKS
 906         &wake_lock_attr.attr,
 907         &wake_unlock_attr.attr,
 908 #endif
 909 #ifdef CONFIG_PM_SLEEP_DEBUG
 910         &pm_test_attr.attr,
 911         &pm_print_times_attr.attr,
 912         &pm_wakeup_irq_attr.attr,
 913         &pm_debug_messages_attr.attr,
 914 #endif
 915 #endif
 916 #ifdef CONFIG_FREEZER
 917         &pm_freeze_timeout_attr.attr,
 918 #endif
 919         NULL,
 920 };
 921
 922 static const struct attribute_group attr_group = {
 923         .attrs = g,
 924 };
 925
 926 static const struct attribute_group *attr_groups[] = {
 927         &attr_group,
 928 #ifdef CONFIG_PM_SLEEP
 929         &suspend_attr_group,
 930 #endif
 931         NULL,
 932 };
 933
 934 struct workqueue_struct *pm_wq;
 935 EXPORT_SYMBOL_GPL(pm_wq);
 936
 937 static int __init pm_start_workqueue(void)
 938 {
 939         pm_wq = alloc_workqueue("pm", WQ_FREEZABLE, 0);
 940
 941         return pm_wq ? 0 : -ENOMEM;
 942 }
 943
 944 static int __init pm_init(void)
 945 {
 946         int error = pm_start_workqueue();
 947         if (error)
 948                 return error;
 949         hibernate_image_size_init();
 950         hibernate_reserved_size_init();
 951         pm_states_init();
 952         power_kobj = kobject_create_and_add("power", NULL);
 953         if (!power_kobj)
 954                 return -ENOMEM;
 955         error = sysfs_create_groups(power_kobj, attr_groups);
 956         if (error)
 957                 return error;
 958         pm_print_times_init();
 959         return pm_autosleep_init();
 960 }
 961
 962 core_initcall(pm_init);