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