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