Linux Audio

Check our new training course

Loading...
v4.17
 
   1/*
   2 * kernel/power/hibernate.c - Hibernation (a.k.a suspend-to-disk) support.
   3 *
   4 * Copyright (c) 2003 Patrick Mochel
   5 * Copyright (c) 2003 Open Source Development Lab
   6 * Copyright (c) 2004 Pavel Machek <pavel@ucw.cz>
   7 * Copyright (c) 2009 Rafael J. Wysocki, Novell Inc.
   8 * Copyright (C) 2012 Bojan Smojver <bojan@rexursive.com>
   9 *
  10 * This file is released under the GPLv2.
  11 */
  12
  13#define pr_fmt(fmt) "PM: " fmt
  14
 
  15#include <linux/export.h>
  16#include <linux/suspend.h>
  17#include <linux/syscalls.h>
  18#include <linux/reboot.h>
  19#include <linux/string.h>
  20#include <linux/device.h>
  21#include <linux/async.h>
  22#include <linux/delay.h>
  23#include <linux/fs.h>
  24#include <linux/mount.h>
  25#include <linux/pm.h>
  26#include <linux/nmi.h>
  27#include <linux/console.h>
  28#include <linux/cpu.h>
  29#include <linux/freezer.h>
  30#include <linux/gfp.h>
  31#include <linux/syscore_ops.h>
  32#include <linux/ctype.h>
  33#include <linux/genhd.h>
  34#include <linux/ktime.h>
 
 
  35#include <trace/events/power.h>
  36
  37#include "power.h"
  38
  39
  40static int nocompress;
  41static int noresume;
  42static int nohibernate;
  43static int resume_wait;
  44static unsigned int resume_delay;
  45static char resume_file[256] = CONFIG_PM_STD_PARTITION;
  46dev_t swsusp_resume_device;
  47sector_t swsusp_resume_block;
  48__visible int in_suspend __nosavedata;
  49
 
 
 
 
 
 
 
 
 
  50enum {
  51	HIBERNATION_INVALID,
  52	HIBERNATION_PLATFORM,
  53	HIBERNATION_SHUTDOWN,
  54	HIBERNATION_REBOOT,
  55#ifdef CONFIG_SUSPEND
  56	HIBERNATION_SUSPEND,
  57#endif
  58	HIBERNATION_TEST_RESUME,
  59	/* keep last */
  60	__HIBERNATION_AFTER_LAST
  61};
  62#define HIBERNATION_MAX (__HIBERNATION_AFTER_LAST-1)
  63#define HIBERNATION_FIRST (HIBERNATION_INVALID + 1)
  64
  65static int hibernation_mode = HIBERNATION_SHUTDOWN;
  66
  67bool freezer_test_done;
  68
  69static const struct platform_hibernation_ops *hibernation_ops;
  70
 
 
 
 
 
 
 
 
 
 
 
 
  71bool hibernation_available(void)
  72{
  73	return (nohibernate == 0);
 
 
  74}
  75
  76/**
  77 * hibernation_set_ops - Set the global hibernate operations.
  78 * @ops: Hibernation operations to use in subsequent hibernation transitions.
  79 */
  80void hibernation_set_ops(const struct platform_hibernation_ops *ops)
  81{
 
 
  82	if (ops && !(ops->begin && ops->end &&  ops->pre_snapshot
  83	    && ops->prepare && ops->finish && ops->enter && ops->pre_restore
  84	    && ops->restore_cleanup && ops->leave)) {
  85		WARN_ON(1);
  86		return;
  87	}
  88	lock_system_sleep();
 
 
  89	hibernation_ops = ops;
  90	if (ops)
  91		hibernation_mode = HIBERNATION_PLATFORM;
  92	else if (hibernation_mode == HIBERNATION_PLATFORM)
  93		hibernation_mode = HIBERNATION_SHUTDOWN;
  94
  95	unlock_system_sleep();
  96}
  97EXPORT_SYMBOL_GPL(hibernation_set_ops);
  98
  99static bool entering_platform_hibernation;
 100
 101bool system_entering_hibernation(void)
 102{
 103	return entering_platform_hibernation;
 104}
 105EXPORT_SYMBOL(system_entering_hibernation);
 106
 107#ifdef CONFIG_PM_DEBUG
 108static void hibernation_debug_sleep(void)
 109{
 110	pr_info("hibernation debug: Waiting for 5 seconds.\n");
 111	mdelay(5000);
 112}
 113
 114static int hibernation_test(int level)
 115{
 116	if (pm_test_level == level) {
 117		hibernation_debug_sleep();
 118		return 1;
 119	}
 120	return 0;
 121}
 122#else /* !CONFIG_PM_DEBUG */
 123static int hibernation_test(int level) { return 0; }
 124#endif /* !CONFIG_PM_DEBUG */
 125
 126/**
 127 * platform_begin - Call platform to start hibernation.
 128 * @platform_mode: Whether or not to use the platform driver.
 129 */
 130static int platform_begin(int platform_mode)
 131{
 132	return (platform_mode && hibernation_ops) ?
 133		hibernation_ops->begin() : 0;
 134}
 135
 136/**
 137 * platform_end - Call platform to finish transition to the working state.
 138 * @platform_mode: Whether or not to use the platform driver.
 139 */
 140static void platform_end(int platform_mode)
 141{
 142	if (platform_mode && hibernation_ops)
 143		hibernation_ops->end();
 144}
 145
 146/**
 147 * platform_pre_snapshot - Call platform to prepare the machine for hibernation.
 148 * @platform_mode: Whether or not to use the platform driver.
 149 *
 150 * Use the platform driver to prepare the system for creating a hibernate image,
 151 * if so configured, and return an error code if that fails.
 152 */
 153
 154static int platform_pre_snapshot(int platform_mode)
 155{
 156	return (platform_mode && hibernation_ops) ?
 157		hibernation_ops->pre_snapshot() : 0;
 158}
 159
 160/**
 161 * platform_leave - Call platform to prepare a transition to the working state.
 162 * @platform_mode: Whether or not to use the platform driver.
 163 *
 164 * Use the platform driver prepare to prepare the machine for switching to the
 165 * normal mode of operation.
 166 *
 167 * This routine is called on one CPU with interrupts disabled.
 168 */
 169static void platform_leave(int platform_mode)
 170{
 171	if (platform_mode && hibernation_ops)
 172		hibernation_ops->leave();
 173}
 174
 175/**
 176 * platform_finish - Call platform to switch the system to the working state.
 177 * @platform_mode: Whether or not to use the platform driver.
 178 *
 179 * Use the platform driver to switch the machine to the normal mode of
 180 * operation.
 181 *
 182 * This routine must be called after platform_prepare().
 183 */
 184static void platform_finish(int platform_mode)
 185{
 186	if (platform_mode && hibernation_ops)
 187		hibernation_ops->finish();
 188}
 189
 190/**
 191 * platform_pre_restore - Prepare for hibernate image restoration.
 192 * @platform_mode: Whether or not to use the platform driver.
 193 *
 194 * Use the platform driver to prepare the system for resume from a hibernation
 195 * image.
 196 *
 197 * If the restore fails after this function has been called,
 198 * platform_restore_cleanup() must be called.
 199 */
 200static int platform_pre_restore(int platform_mode)
 201{
 202	return (platform_mode && hibernation_ops) ?
 203		hibernation_ops->pre_restore() : 0;
 204}
 205
 206/**
 207 * platform_restore_cleanup - Switch to the working state after failing restore.
 208 * @platform_mode: Whether or not to use the platform driver.
 209 *
 210 * Use the platform driver to switch the system to the normal mode of operation
 211 * after a failing restore.
 212 *
 213 * If platform_pre_restore() has been called before the failing restore, this
 214 * function must be called too, regardless of the result of
 215 * platform_pre_restore().
 216 */
 217static void platform_restore_cleanup(int platform_mode)
 218{
 219	if (platform_mode && hibernation_ops)
 220		hibernation_ops->restore_cleanup();
 221}
 222
 223/**
 224 * platform_recover - Recover from a failure to suspend devices.
 225 * @platform_mode: Whether or not to use the platform driver.
 226 */
 227static void platform_recover(int platform_mode)
 228{
 229	if (platform_mode && hibernation_ops && hibernation_ops->recover)
 230		hibernation_ops->recover();
 231}
 232
 233/**
 234 * swsusp_show_speed - Print time elapsed between two events during hibernation.
 235 * @start: Starting event.
 236 * @stop: Final event.
 237 * @nr_pages: Number of memory pages processed between @start and @stop.
 238 * @msg: Additional diagnostic message to print.
 239 */
 240void swsusp_show_speed(ktime_t start, ktime_t stop,
 241		      unsigned nr_pages, char *msg)
 242{
 243	ktime_t diff;
 244	u64 elapsed_centisecs64;
 245	unsigned int centisecs;
 246	unsigned int k;
 247	unsigned int kps;
 248
 249	diff = ktime_sub(stop, start);
 250	elapsed_centisecs64 = ktime_divns(diff, 10*NSEC_PER_MSEC);
 251	centisecs = elapsed_centisecs64;
 252	if (centisecs == 0)
 253		centisecs = 1;	/* avoid div-by-zero */
 254	k = nr_pages * (PAGE_SIZE / 1024);
 255	kps = (k * 100) / centisecs;
 256	pr_info("%s %u kbytes in %u.%02u seconds (%u.%02u MB/s)\n",
 257		msg, k, centisecs / 100, centisecs % 100, kps / 1000,
 258		(kps % 1000) / 10);
 259}
 260
 
 
 
 
 
 261/**
 262 * create_image - Create a hibernation image.
 263 * @platform_mode: Whether or not to use the platform driver.
 264 *
 265 * Execute device drivers' "late" and "noirq" freeze callbacks, create a
 266 * hibernation image and run the drivers' "noirq" and "early" thaw callbacks.
 267 *
 268 * Control reappears in this routine after the subsequent restore.
 269 */
 270static int create_image(int platform_mode)
 271{
 272	int error;
 273
 274	error = dpm_suspend_end(PMSG_FREEZE);
 275	if (error) {
 276		pr_err("Some devices failed to power down, aborting hibernation\n");
 277		return error;
 278	}
 279
 280	error = platform_pre_snapshot(platform_mode);
 281	if (error || hibernation_test(TEST_PLATFORM))
 282		goto Platform_finish;
 283
 284	error = disable_nonboot_cpus();
 285	if (error || hibernation_test(TEST_CPUS))
 286		goto Enable_cpus;
 287
 288	local_irq_disable();
 289
 
 
 290	error = syscore_suspend();
 291	if (error) {
 292		pr_err("Some system devices failed to power down, aborting hibernation\n");
 293		goto Enable_irqs;
 294	}
 295
 296	if (hibernation_test(TEST_CORE) || pm_wakeup_pending())
 297		goto Power_up;
 298
 299	in_suspend = 1;
 300	save_processor_state();
 301	trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, true);
 302	error = swsusp_arch_suspend();
 303	/* Restore control flow magically appears here */
 304	restore_processor_state();
 305	trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, false);
 306	if (error)
 307		pr_err("Error %d creating hibernation image\n", error);
 308
 309	if (!in_suspend) {
 310		events_check_enabled = false;
 311		clear_free_pages();
 312	}
 313
 314	platform_leave(platform_mode);
 315
 316 Power_up:
 317	syscore_resume();
 318
 319 Enable_irqs:
 
 320	local_irq_enable();
 321
 322 Enable_cpus:
 323	enable_nonboot_cpus();
 
 
 
 
 324
 325 Platform_finish:
 326	platform_finish(platform_mode);
 327
 328	dpm_resume_start(in_suspend ?
 329		(error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
 330
 331	return error;
 332}
 333
 334/**
 335 * hibernation_snapshot - Quiesce devices and create a hibernation image.
 336 * @platform_mode: If set, use platform driver to prepare for the transition.
 337 *
 338 * This routine must be called with pm_mutex held.
 339 */
 340int hibernation_snapshot(int platform_mode)
 341{
 342	pm_message_t msg;
 343	int error;
 344
 345	pm_suspend_clear_flags();
 346	error = platform_begin(platform_mode);
 347	if (error)
 348		goto Close;
 349
 350	/* Preallocate image memory before shutting down devices. */
 351	error = hibernate_preallocate_memory();
 352	if (error)
 353		goto Close;
 354
 355	error = freeze_kernel_threads();
 356	if (error)
 357		goto Cleanup;
 358
 359	if (hibernation_test(TEST_FREEZER)) {
 360
 361		/*
 362		 * Indicate to the caller that we are returning due to a
 363		 * successful freezer test.
 364		 */
 365		freezer_test_done = true;
 366		goto Thaw;
 367	}
 368
 369	error = dpm_prepare(PMSG_FREEZE);
 370	if (error) {
 371		dpm_complete(PMSG_RECOVER);
 372		goto Thaw;
 373	}
 374
 375	suspend_console();
 376	pm_restrict_gfp_mask();
 377
 378	error = dpm_suspend(PMSG_FREEZE);
 379
 380	if (error || hibernation_test(TEST_DEVICES))
 381		platform_recover(platform_mode);
 382	else
 383		error = create_image(platform_mode);
 384
 385	/*
 386	 * In the case that we call create_image() above, the control
 387	 * returns here (1) after the image has been created or the
 388	 * image creation has failed and (2) after a successful restore.
 389	 */
 390
 391	/* We may need to release the preallocated image pages here. */
 392	if (error || !in_suspend)
 393		swsusp_free();
 394
 395	msg = in_suspend ? (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE;
 396	dpm_resume(msg);
 397
 398	if (error || !in_suspend)
 399		pm_restore_gfp_mask();
 400
 401	resume_console();
 402	dpm_complete(msg);
 403
 404 Close:
 405	platform_end(platform_mode);
 406	return error;
 407
 408 Thaw:
 409	thaw_kernel_threads();
 410 Cleanup:
 411	swsusp_free();
 412	goto Close;
 413}
 414
 415int __weak hibernate_resume_nonboot_cpu_disable(void)
 416{
 417	return disable_nonboot_cpus();
 418}
 419
 420/**
 421 * resume_target_kernel - Restore system state from a hibernation image.
 422 * @platform_mode: Whether or not to use the platform driver.
 423 *
 424 * Execute device drivers' "noirq" and "late" freeze callbacks, restore the
 425 * contents of highmem that have not been restored yet from the image and run
 426 * the low-level code that will restore the remaining contents of memory and
 427 * switch to the just restored target kernel.
 428 */
 429static int resume_target_kernel(bool platform_mode)
 430{
 431	int error;
 432
 433	error = dpm_suspend_end(PMSG_QUIESCE);
 434	if (error) {
 435		pr_err("Some devices failed to power down, aborting resume\n");
 436		return error;
 437	}
 438
 439	error = platform_pre_restore(platform_mode);
 440	if (error)
 441		goto Cleanup;
 442
 
 
 443	error = hibernate_resume_nonboot_cpu_disable();
 444	if (error)
 445		goto Enable_cpus;
 446
 447	local_irq_disable();
 
 448
 449	error = syscore_suspend();
 450	if (error)
 451		goto Enable_irqs;
 452
 453	save_processor_state();
 454	error = restore_highmem();
 455	if (!error) {
 456		error = swsusp_arch_resume();
 457		/*
 458		 * The code below is only ever reached in case of a failure.
 459		 * Otherwise, execution continues at the place where
 460		 * swsusp_arch_suspend() was called.
 461		 */
 462		BUG_ON(!error);
 463		/*
 464		 * This call to restore_highmem() reverts the changes made by
 465		 * the previous one.
 466		 */
 467		restore_highmem();
 468	}
 469	/*
 470	 * The only reason why swsusp_arch_resume() can fail is memory being
 471	 * very tight, so we have to free it as soon as we can to avoid
 472	 * subsequent failures.
 473	 */
 474	swsusp_free();
 475	restore_processor_state();
 476	touch_softlockup_watchdog();
 477
 478	syscore_resume();
 479
 480 Enable_irqs:
 
 481	local_irq_enable();
 482
 483 Enable_cpus:
 484	enable_nonboot_cpus();
 485
 486 Cleanup:
 487	platform_restore_cleanup(platform_mode);
 488
 489	dpm_resume_start(PMSG_RECOVER);
 490
 491	return error;
 492}
 493
 494/**
 495 * hibernation_restore - Quiesce devices and restore from a hibernation image.
 496 * @platform_mode: If set, use platform driver to prepare for the transition.
 497 *
 498 * This routine must be called with pm_mutex held.  If it is successful, control
 499 * reappears in the restored target kernel in hibernation_snapshot().
 
 500 */
 501int hibernation_restore(int platform_mode)
 502{
 503	int error;
 504
 505	pm_prepare_console();
 506	suspend_console();
 507	pm_restrict_gfp_mask();
 508	error = dpm_suspend_start(PMSG_QUIESCE);
 509	if (!error) {
 510		error = resume_target_kernel(platform_mode);
 511		/*
 512		 * The above should either succeed and jump to the new kernel,
 513		 * or return with an error. Otherwise things are just
 514		 * undefined, so let's be paranoid.
 515		 */
 516		BUG_ON(!error);
 517	}
 518	dpm_resume_end(PMSG_RECOVER);
 519	pm_restore_gfp_mask();
 520	resume_console();
 521	pm_restore_console();
 522	return error;
 523}
 524
 525/**
 526 * hibernation_platform_enter - Power off the system using the platform driver.
 527 */
 528int hibernation_platform_enter(void)
 529{
 530	int error;
 531
 532	if (!hibernation_ops)
 533		return -ENOSYS;
 534
 535	/*
 536	 * We have cancelled the power transition by running
 537	 * hibernation_ops->finish() before saving the image, so we should let
 538	 * the firmware know that we're going to enter the sleep state after all
 539	 */
 540	error = hibernation_ops->begin();
 541	if (error)
 542		goto Close;
 543
 544	entering_platform_hibernation = true;
 545	suspend_console();
 546	error = dpm_suspend_start(PMSG_HIBERNATE);
 547	if (error) {
 548		if (hibernation_ops->recover)
 549			hibernation_ops->recover();
 550		goto Resume_devices;
 551	}
 552
 553	error = dpm_suspend_end(PMSG_HIBERNATE);
 554	if (error)
 555		goto Resume_devices;
 556
 557	error = hibernation_ops->prepare();
 558	if (error)
 559		goto Platform_finish;
 560
 561	error = disable_nonboot_cpus();
 562	if (error)
 563		goto Enable_cpus;
 564
 565	local_irq_disable();
 566	syscore_suspend();
 
 
 
 
 
 567	if (pm_wakeup_pending()) {
 568		error = -EAGAIN;
 569		goto Power_up;
 570	}
 571
 572	hibernation_ops->enter();
 573	/* We should never get here */
 574	while (1);
 575
 576 Power_up:
 577	syscore_resume();
 
 
 578	local_irq_enable();
 579
 580 Enable_cpus:
 581	enable_nonboot_cpus();
 582
 583 Platform_finish:
 584	hibernation_ops->finish();
 585
 586	dpm_resume_start(PMSG_RESTORE);
 587
 588 Resume_devices:
 589	entering_platform_hibernation = false;
 590	dpm_resume_end(PMSG_RESTORE);
 591	resume_console();
 592
 593 Close:
 594	hibernation_ops->end();
 595
 596	return error;
 597}
 598
 599/**
 600 * power_down - Shut the machine down for hibernation.
 601 *
 602 * Use the platform driver, if configured, to put the system into the sleep
 603 * state corresponding to hibernation, or try to power it off or reboot,
 604 * depending on the value of hibernation_mode.
 605 */
 606static void power_down(void)
 607{
 608#ifdef CONFIG_SUSPEND
 609	int error;
 610
 
 611	if (hibernation_mode == HIBERNATION_SUSPEND) {
 612		error = suspend_devices_and_enter(PM_SUSPEND_MEM);
 613		if (error) {
 614			hibernation_mode = hibernation_ops ?
 615						HIBERNATION_PLATFORM :
 616						HIBERNATION_SHUTDOWN;
 617		} else {
 618			/* Restore swap signature. */
 619			error = swsusp_unmark();
 620			if (error)
 621				pr_err("Swap will be unusable! Try swapon -a.\n");
 622
 623			return;
 624		}
 625	}
 626#endif
 627
 628	switch (hibernation_mode) {
 629	case HIBERNATION_REBOOT:
 630		kernel_restart(NULL);
 631		break;
 632	case HIBERNATION_PLATFORM:
 633		hibernation_platform_enter();
 
 
 
 
 
 
 
 634	case HIBERNATION_SHUTDOWN:
 635		if (pm_power_off)
 
 636			kernel_power_off();
 
 
 637		break;
 638	}
 639	kernel_halt();
 640	/*
 641	 * Valid image is on the disk, if we continue we risk serious data
 642	 * corruption after resume.
 643	 */
 644	pr_crit("Power down manually\n");
 645	while (1)
 646		cpu_relax();
 647}
 648
 649static int load_image_and_restore(void)
 650{
 651	int error;
 652	unsigned int flags;
 653
 654	pm_pr_dbg("Loading hibernation image.\n");
 655
 656	lock_device_hotplug();
 657	error = create_basic_memory_bitmaps();
 658	if (error)
 
 659		goto Unlock;
 
 660
 661	error = swsusp_read(&flags);
 662	swsusp_close(FMODE_READ);
 663	if (!error)
 664		hibernation_restore(flags & SF_PLATFORM_MODE);
 665
 666	pr_err("Failed to load hibernation image, recovering.\n");
 667	swsusp_free();
 668	free_basic_memory_bitmaps();
 669 Unlock:
 670	unlock_device_hotplug();
 671
 672	return error;
 673}
 674
 
 
 
 675/**
 676 * hibernate - Carry out system hibernation, including saving the image.
 677 */
 678int hibernate(void)
 679{
 680	int error, nr_calls = 0;
 681	bool snapshot_test = false;
 
 
 682
 683	if (!hibernation_available()) {
 684		pm_pr_dbg("Hibernation not available.\n");
 685		return -EPERM;
 686	}
 687
 688	lock_system_sleep();
 
 
 
 
 
 
 
 
 
 
 
 689	/* The snapshot device should not be opened while we're running */
 690	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
 691		error = -EBUSY;
 692		goto Unlock;
 693	}
 694
 695	pr_info("hibernation entry\n");
 696	pm_prepare_console();
 697	error = __pm_notifier_call_chain(PM_HIBERNATION_PREPARE, -1, &nr_calls);
 698	if (error) {
 699		nr_calls--;
 700		goto Exit;
 701	}
 702
 703	pr_info("Syncing filesystems ... \n");
 704	ksys_sync();
 705	pr_info("done.\n");
 706
 707	error = freeze_processes();
 708	if (error)
 709		goto Exit;
 710
 711	lock_device_hotplug();
 712	/* Allocate memory management structures */
 713	error = create_basic_memory_bitmaps();
 714	if (error)
 715		goto Thaw;
 716
 717	error = hibernation_snapshot(hibernation_mode == HIBERNATION_PLATFORM);
 718	if (error || freezer_test_done)
 719		goto Free_bitmaps;
 720
 721	if (in_suspend) {
 722		unsigned int flags = 0;
 723
 724		if (hibernation_mode == HIBERNATION_PLATFORM)
 725			flags |= SF_PLATFORM_MODE;
 726		if (nocompress)
 727			flags |= SF_NOCOMPRESS_MODE;
 728		else
 729		        flags |= SF_CRC32_MODE;
 730
 731		pm_pr_dbg("Writing image.\n");
 
 
 
 
 
 
 
 
 
 
 
 
 
 732		error = swsusp_write(flags);
 733		swsusp_free();
 734		if (!error) {
 735			if (hibernation_mode == HIBERNATION_TEST_RESUME)
 736				snapshot_test = true;
 737			else
 738				power_down();
 739		}
 740		in_suspend = 0;
 741		pm_restore_gfp_mask();
 742	} else {
 743		pm_pr_dbg("Image restored successfully.\n");
 744	}
 745
 746 Free_bitmaps:
 747	free_basic_memory_bitmaps();
 748 Thaw:
 749	unlock_device_hotplug();
 750	if (snapshot_test) {
 751		pm_pr_dbg("Checking hibernation image\n");
 752		error = swsusp_check();
 753		if (!error)
 754			error = load_image_and_restore();
 755	}
 756	thaw_processes();
 757
 758	/* Don't bother checking whether freezer_test_done is true */
 759	freezer_test_done = false;
 760 Exit:
 761	__pm_notifier_call_chain(PM_POST_HIBERNATION, nr_calls, NULL);
 
 762	pm_restore_console();
 763	atomic_inc(&snapshot_device_available);
 764 Unlock:
 765	unlock_system_sleep();
 766	pr_info("hibernation exit\n");
 767
 768	return error;
 769}
 770
 771
 772/**
 773 * software_resume - Resume from a saved hibernation image.
 774 *
 775 * This routine is called as a late initcall, when all devices have been
 776 * discovered and initialized already.
 777 *
 778 * The image reading code is called to see if there is a hibernation image
 779 * available for reading.  If that is the case, devices are quiesced and the
 780 * contents of memory is restored from the saved image.
 781 *
 782 * If this is successful, control reappears in the restored target kernel in
 783 * hibernation_snapshot() which returns to hibernate().  Otherwise, the routine
 784 * attempts to recover gracefully and make the kernel return to the normal mode
 785 * of operation.
 786 */
 787static int software_resume(void)
 788{
 789	int error, nr_calls = 0;
 
 790
 791	/*
 792	 * If the user said "noresume".. bail out early.
 793	 */
 794	if (noresume || !hibernation_available())
 795		return 0;
 796
 797	/*
 798	 * name_to_dev_t() below takes a sysfs buffer mutex when sysfs
 799	 * is configured into the kernel. Since the regular hibernate
 800	 * trigger path is via sysfs which takes a buffer mutex before
 801	 * calling hibernate functions (which take pm_mutex) this can
 802	 * cause lockdep to complain about a possible ABBA deadlock
 803	 * which cannot happen since we're in the boot code here and
 804	 * sysfs can't be invoked yet. Therefore, we use a subclass
 805	 * here to avoid lockdep complaining.
 806	 */
 807	mutex_lock_nested(&pm_mutex, SINGLE_DEPTH_NESTING);
 808
 809	if (swsusp_resume_device)
 810		goto Check_image;
 811
 812	if (!strlen(resume_file)) {
 813		error = -ENOENT;
 814		goto Unlock;
 815	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 816
 817	pm_pr_dbg("Checking hibernation image partition %s\n", resume_file);
 818
 819	if (resume_delay) {
 820		pr_info("Waiting %dsec before reading resume device ...\n",
 821			resume_delay);
 822		ssleep(resume_delay);
 823	}
 824
 825	/* Check if the device is there */
 826	swsusp_resume_device = name_to_dev_t(resume_file);
 
 827
 828	/*
 829	 * name_to_dev_t is ineffective to verify parition if resume_file is in
 830	 * integer format. (e.g. major:minor)
 831	 */
 832	if (isdigit(resume_file[0]) && resume_wait) {
 833		int partno;
 834		while (!get_gendisk(swsusp_resume_device, &partno))
 835			msleep(10);
 
 836	}
 837
 838	if (!swsusp_resume_device) {
 839		/*
 840		 * Some device discovery might still be in progress; we need
 841		 * to wait for this to finish.
 842		 */
 843		wait_for_device_probe();
 844
 845		if (resume_wait) {
 846			while ((swsusp_resume_device = name_to_dev_t(resume_file)) == 0)
 847				msleep(10);
 848			async_synchronize_full();
 849		}
 850
 851		swsusp_resume_device = name_to_dev_t(resume_file);
 852		if (!swsusp_resume_device) {
 853			error = -ENODEV;
 854			goto Unlock;
 855		}
 856	}
 857
 858 Check_image:
 859	pm_pr_dbg("Hibernation image partition %d:%d present\n",
 860		MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
 861
 862	pm_pr_dbg("Looking for hibernation image.\n");
 863	error = swsusp_check();
 
 
 864	if (error)
 865		goto Unlock;
 866
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 867	/* The snapshot device should not be opened while we're running */
 868	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
 869		error = -EBUSY;
 870		swsusp_close(FMODE_READ);
 871		goto Unlock;
 872	}
 873
 874	pr_info("resume from hibernation\n");
 875	pm_prepare_console();
 876	error = __pm_notifier_call_chain(PM_RESTORE_PREPARE, -1, &nr_calls);
 877	if (error) {
 878		nr_calls--;
 879		goto Close_Finish;
 880	}
 881
 882	pm_pr_dbg("Preparing processes for restore.\n");
 883	error = freeze_processes();
 884	if (error)
 885		goto Close_Finish;
 
 
 
 
 
 
 
 886	error = load_image_and_restore();
 887	thaw_processes();
 888 Finish:
 889	__pm_notifier_call_chain(PM_POST_RESTORE, nr_calls, NULL);
 
 890	pm_restore_console();
 891	pr_info("resume from hibernation failed (%d)\n", error);
 892	atomic_inc(&snapshot_device_available);
 893	/* For success case, the suspend path will release the lock */
 894 Unlock:
 895	mutex_unlock(&pm_mutex);
 896	pm_pr_dbg("Hibernation image not present or could not be loaded.\n");
 897	return error;
 898 Close_Finish:
 899	swsusp_close(FMODE_READ);
 900	goto Finish;
 901}
 902
 903late_initcall_sync(software_resume);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 904
 905
 906static const char * const hibernation_modes[] = {
 907	[HIBERNATION_PLATFORM]	= "platform",
 908	[HIBERNATION_SHUTDOWN]	= "shutdown",
 909	[HIBERNATION_REBOOT]	= "reboot",
 910#ifdef CONFIG_SUSPEND
 911	[HIBERNATION_SUSPEND]	= "suspend",
 912#endif
 913	[HIBERNATION_TEST_RESUME]	= "test_resume",
 914};
 915
 916/*
 917 * /sys/power/disk - Control hibernation mode.
 918 *
 919 * Hibernation can be handled in several ways.  There are a few different ways
 920 * to put the system into the sleep state: using the platform driver (e.g. ACPI
 921 * or other hibernation_ops), powering it off or rebooting it (for testing
 922 * mostly).
 923 *
 924 * The sysfs file /sys/power/disk provides an interface for selecting the
 925 * hibernation mode to use.  Reading from this file causes the available modes
 926 * to be printed.  There are 3 modes that can be supported:
 927 *
 928 *	'platform'
 929 *	'shutdown'
 930 *	'reboot'
 931 *
 932 * If a platform hibernation driver is in use, 'platform' will be supported
 933 * and will be used by default.  Otherwise, 'shutdown' will be used by default.
 934 * The selected option (i.e. the one corresponding to the current value of
 935 * hibernation_mode) is enclosed by a square bracket.
 936 *
 937 * To select a given hibernation mode it is necessary to write the mode's
 938 * string representation (as returned by reading from /sys/power/disk) back
 939 * into /sys/power/disk.
 940 */
 941
 942static ssize_t disk_show(struct kobject *kobj, struct kobj_attribute *attr,
 943			 char *buf)
 944{
 
 945	int i;
 946	char *start = buf;
 947
 948	if (!hibernation_available())
 949		return sprintf(buf, "[disabled]\n");
 950
 951	for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
 952		if (!hibernation_modes[i])
 953			continue;
 954		switch (i) {
 955		case HIBERNATION_SHUTDOWN:
 956		case HIBERNATION_REBOOT:
 957#ifdef CONFIG_SUSPEND
 958		case HIBERNATION_SUSPEND:
 959#endif
 960		case HIBERNATION_TEST_RESUME:
 961			break;
 962		case HIBERNATION_PLATFORM:
 963			if (hibernation_ops)
 964				break;
 965			/* not a valid mode, continue with loop */
 966			continue;
 967		}
 968		if (i == hibernation_mode)
 969			buf += sprintf(buf, "[%s] ", hibernation_modes[i]);
 970		else
 971			buf += sprintf(buf, "%s ", hibernation_modes[i]);
 972	}
 973	buf += sprintf(buf, "\n");
 974	return buf-start;
 
 
 
 
 975}
 976
 977static ssize_t disk_store(struct kobject *kobj, struct kobj_attribute *attr,
 978			  const char *buf, size_t n)
 979{
 
 
 980	int error = 0;
 981	int i;
 982	int len;
 983	char *p;
 984	int mode = HIBERNATION_INVALID;
 985
 986	if (!hibernation_available())
 987		return -EPERM;
 988
 989	p = memchr(buf, '\n', n);
 990	len = p ? p - buf : n;
 991
 992	lock_system_sleep();
 993	for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
 994		if (len == strlen(hibernation_modes[i])
 995		    && !strncmp(buf, hibernation_modes[i], len)) {
 996			mode = i;
 997			break;
 998		}
 999	}
1000	if (mode != HIBERNATION_INVALID) {
1001		switch (mode) {
1002		case HIBERNATION_SHUTDOWN:
1003		case HIBERNATION_REBOOT:
1004#ifdef CONFIG_SUSPEND
1005		case HIBERNATION_SUSPEND:
1006#endif
1007		case HIBERNATION_TEST_RESUME:
1008			hibernation_mode = mode;
1009			break;
1010		case HIBERNATION_PLATFORM:
1011			if (hibernation_ops)
1012				hibernation_mode = mode;
1013			else
1014				error = -EINVAL;
1015		}
1016	} else
1017		error = -EINVAL;
1018
1019	if (!error)
1020		pm_pr_dbg("Hibernation mode set to '%s'\n",
1021			       hibernation_modes[mode]);
1022	unlock_system_sleep();
1023	return error ? error : n;
1024}
1025
1026power_attr(disk);
1027
1028static ssize_t resume_show(struct kobject *kobj, struct kobj_attribute *attr,
1029			   char *buf)
1030{
1031	return sprintf(buf,"%d:%d\n", MAJOR(swsusp_resume_device),
1032		       MINOR(swsusp_resume_device));
1033}
1034
1035static ssize_t resume_store(struct kobject *kobj, struct kobj_attribute *attr,
1036			    const char *buf, size_t n)
1037{
1038	dev_t res;
1039	int len = n;
1040	char *name;
 
 
 
 
 
1041
1042	if (len && buf[len-1] == '\n')
1043		len--;
1044	name = kstrndup(buf, len, GFP_KERNEL);
1045	if (!name)
1046		return -ENOMEM;
1047
1048	res = name_to_dev_t(name);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1049	kfree(name);
1050	if (!res)
1051		return -EINVAL;
1052
1053	lock_system_sleep();
1054	swsusp_resume_device = res;
1055	unlock_system_sleep();
1056	pm_pr_dbg("Configured resume from disk to %u\n", swsusp_resume_device);
 
 
1057	noresume = 0;
1058	software_resume();
1059	return n;
1060}
1061
1062power_attr(resume);
1063
1064static ssize_t resume_offset_show(struct kobject *kobj,
1065				  struct kobj_attribute *attr, char *buf)
1066{
1067	return sprintf(buf, "%llu\n", (unsigned long long)swsusp_resume_block);
1068}
1069
1070static ssize_t resume_offset_store(struct kobject *kobj,
1071				   struct kobj_attribute *attr, const char *buf,
1072				   size_t n)
1073{
1074	unsigned long long offset;
1075	int rc;
1076
1077	rc = kstrtoull(buf, 0, &offset);
1078	if (rc)
1079		return rc;
1080	swsusp_resume_block = offset;
1081
1082	return n;
1083}
1084
1085power_attr(resume_offset);
1086
1087static ssize_t image_size_show(struct kobject *kobj, struct kobj_attribute *attr,
1088			       char *buf)
1089{
1090	return sprintf(buf, "%lu\n", image_size);
1091}
1092
1093static ssize_t image_size_store(struct kobject *kobj, struct kobj_attribute *attr,
1094				const char *buf, size_t n)
1095{
1096	unsigned long size;
1097
1098	if (sscanf(buf, "%lu", &size) == 1) {
1099		image_size = size;
1100		return n;
1101	}
1102
1103	return -EINVAL;
1104}
1105
1106power_attr(image_size);
1107
1108static ssize_t reserved_size_show(struct kobject *kobj,
1109				  struct kobj_attribute *attr, char *buf)
1110{
1111	return sprintf(buf, "%lu\n", reserved_size);
1112}
1113
1114static ssize_t reserved_size_store(struct kobject *kobj,
1115				   struct kobj_attribute *attr,
1116				   const char *buf, size_t n)
1117{
1118	unsigned long size;
1119
1120	if (sscanf(buf, "%lu", &size) == 1) {
1121		reserved_size = size;
1122		return n;
1123	}
1124
1125	return -EINVAL;
1126}
1127
1128power_attr(reserved_size);
1129
1130static struct attribute * g[] = {
1131	&disk_attr.attr,
1132	&resume_offset_attr.attr,
1133	&resume_attr.attr,
1134	&image_size_attr.attr,
1135	&reserved_size_attr.attr,
1136	NULL,
1137};
1138
1139
1140static const struct attribute_group attr_group = {
1141	.attrs = g,
1142};
1143
1144
1145static int __init pm_disk_init(void)
1146{
1147	return sysfs_create_group(power_kobj, &attr_group);
1148}
1149
1150core_initcall(pm_disk_init);
1151
1152
1153static int __init resume_setup(char *str)
1154{
1155	if (noresume)
1156		return 1;
1157
1158	strncpy( resume_file, str, 255 );
1159	return 1;
1160}
1161
1162static int __init resume_offset_setup(char *str)
1163{
1164	unsigned long long offset;
1165
1166	if (noresume)
1167		return 1;
1168
1169	if (sscanf(str, "%llu", &offset) == 1)
1170		swsusp_resume_block = offset;
1171
1172	return 1;
1173}
1174
1175static int __init hibernate_setup(char *str)
1176{
1177	if (!strncmp(str, "noresume", 8)) {
1178		noresume = 1;
1179	} else if (!strncmp(str, "nocompress", 10)) {
1180		nocompress = 1;
1181	} else if (!strncmp(str, "no", 2)) {
1182		noresume = 1;
1183		nohibernate = 1;
1184	} else if (IS_ENABLED(CONFIG_STRICT_KERNEL_RWX)
1185		   && !strncmp(str, "protect_image", 13)) {
1186		enable_restore_image_protection();
1187	}
1188	return 1;
1189}
1190
1191static int __init noresume_setup(char *str)
1192{
1193	noresume = 1;
1194	return 1;
1195}
1196
1197static int __init resumewait_setup(char *str)
1198{
1199	resume_wait = 1;
1200	return 1;
1201}
1202
1203static int __init resumedelay_setup(char *str)
1204{
1205	int rc = kstrtouint(str, 0, &resume_delay);
1206
1207	if (rc)
1208		return rc;
1209	return 1;
1210}
1211
1212static int __init nohibernate_setup(char *str)
1213{
1214	noresume = 1;
1215	nohibernate = 1;
1216	return 1;
1217}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1218
1219__setup("noresume", noresume_setup);
1220__setup("resume_offset=", resume_offset_setup);
1221__setup("resume=", resume_setup);
1222__setup("hibernate=", hibernate_setup);
1223__setup("resumewait", resumewait_setup);
1224__setup("resumedelay=", resumedelay_setup);
1225__setup("nohibernate", nohibernate_setup);
v6.13.7
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * kernel/power/hibernate.c - Hibernation (a.k.a suspend-to-disk) support.
   4 *
   5 * Copyright (c) 2003 Patrick Mochel
   6 * Copyright (c) 2003 Open Source Development Lab
   7 * Copyright (c) 2004 Pavel Machek <pavel@ucw.cz>
   8 * Copyright (c) 2009 Rafael J. Wysocki, Novell Inc.
   9 * Copyright (C) 2012 Bojan Smojver <bojan@rexursive.com>
 
 
  10 */
  11
  12#define pr_fmt(fmt) "PM: hibernation: " fmt
  13
  14#include <linux/blkdev.h>
  15#include <linux/export.h>
  16#include <linux/suspend.h>
 
  17#include <linux/reboot.h>
  18#include <linux/string.h>
  19#include <linux/device.h>
  20#include <linux/async.h>
  21#include <linux/delay.h>
  22#include <linux/fs.h>
  23#include <linux/mount.h>
  24#include <linux/pm.h>
  25#include <linux/nmi.h>
  26#include <linux/console.h>
  27#include <linux/cpu.h>
  28#include <linux/freezer.h>
  29#include <linux/gfp.h>
  30#include <linux/syscore_ops.h>
  31#include <linux/ctype.h>
 
  32#include <linux/ktime.h>
  33#include <linux/security.h>
  34#include <linux/secretmem.h>
  35#include <trace/events/power.h>
  36
  37#include "power.h"
  38
  39
  40static int nocompress;
  41static int noresume;
  42static int nohibernate;
  43static int resume_wait;
  44static unsigned int resume_delay;
  45static char resume_file[256] = CONFIG_PM_STD_PARTITION;
  46dev_t swsusp_resume_device;
  47sector_t swsusp_resume_block;
  48__visible int in_suspend __nosavedata;
  49
  50static char hibernate_compressor[CRYPTO_MAX_ALG_NAME] = CONFIG_HIBERNATION_DEF_COMP;
  51
  52/*
  53 * Compression/decompression algorithm to be used while saving/loading
  54 * image to/from disk. This would later be used in 'kernel/power/swap.c'
  55 * to allocate comp streams.
  56 */
  57char hib_comp_algo[CRYPTO_MAX_ALG_NAME];
  58
  59enum {
  60	HIBERNATION_INVALID,
  61	HIBERNATION_PLATFORM,
  62	HIBERNATION_SHUTDOWN,
  63	HIBERNATION_REBOOT,
  64#ifdef CONFIG_SUSPEND
  65	HIBERNATION_SUSPEND,
  66#endif
  67	HIBERNATION_TEST_RESUME,
  68	/* keep last */
  69	__HIBERNATION_AFTER_LAST
  70};
  71#define HIBERNATION_MAX (__HIBERNATION_AFTER_LAST-1)
  72#define HIBERNATION_FIRST (HIBERNATION_INVALID + 1)
  73
  74static int hibernation_mode = HIBERNATION_SHUTDOWN;
  75
  76bool freezer_test_done;
  77
  78static const struct platform_hibernation_ops *hibernation_ops;
  79
  80static atomic_t hibernate_atomic = ATOMIC_INIT(1);
  81
  82bool hibernate_acquire(void)
  83{
  84	return atomic_add_unless(&hibernate_atomic, -1, 0);
  85}
  86
  87void hibernate_release(void)
  88{
  89	atomic_inc(&hibernate_atomic);
  90}
  91
  92bool hibernation_available(void)
  93{
  94	return nohibernate == 0 &&
  95		!security_locked_down(LOCKDOWN_HIBERNATION) &&
  96		!secretmem_active() && !cxl_mem_active();
  97}
  98
  99/**
 100 * hibernation_set_ops - Set the global hibernate operations.
 101 * @ops: Hibernation operations to use in subsequent hibernation transitions.
 102 */
 103void hibernation_set_ops(const struct platform_hibernation_ops *ops)
 104{
 105	unsigned int sleep_flags;
 106
 107	if (ops && !(ops->begin && ops->end &&  ops->pre_snapshot
 108	    && ops->prepare && ops->finish && ops->enter && ops->pre_restore
 109	    && ops->restore_cleanup && ops->leave)) {
 110		WARN_ON(1);
 111		return;
 112	}
 113
 114	sleep_flags = lock_system_sleep();
 115
 116	hibernation_ops = ops;
 117	if (ops)
 118		hibernation_mode = HIBERNATION_PLATFORM;
 119	else if (hibernation_mode == HIBERNATION_PLATFORM)
 120		hibernation_mode = HIBERNATION_SHUTDOWN;
 121
 122	unlock_system_sleep(sleep_flags);
 123}
 124EXPORT_SYMBOL_GPL(hibernation_set_ops);
 125
 126static bool entering_platform_hibernation;
 127
 128bool system_entering_hibernation(void)
 129{
 130	return entering_platform_hibernation;
 131}
 132EXPORT_SYMBOL(system_entering_hibernation);
 133
 134#ifdef CONFIG_PM_DEBUG
 135static void hibernation_debug_sleep(void)
 136{
 137	pr_info("debug: Waiting for 5 seconds.\n");
 138	mdelay(5000);
 139}
 140
 141static int hibernation_test(int level)
 142{
 143	if (pm_test_level == level) {
 144		hibernation_debug_sleep();
 145		return 1;
 146	}
 147	return 0;
 148}
 149#else /* !CONFIG_PM_DEBUG */
 150static int hibernation_test(int level) { return 0; }
 151#endif /* !CONFIG_PM_DEBUG */
 152
 153/**
 154 * platform_begin - Call platform to start hibernation.
 155 * @platform_mode: Whether or not to use the platform driver.
 156 */
 157static int platform_begin(int platform_mode)
 158{
 159	return (platform_mode && hibernation_ops) ?
 160		hibernation_ops->begin(PMSG_FREEZE) : 0;
 161}
 162
 163/**
 164 * platform_end - Call platform to finish transition to the working state.
 165 * @platform_mode: Whether or not to use the platform driver.
 166 */
 167static void platform_end(int platform_mode)
 168{
 169	if (platform_mode && hibernation_ops)
 170		hibernation_ops->end();
 171}
 172
 173/**
 174 * platform_pre_snapshot - Call platform to prepare the machine for hibernation.
 175 * @platform_mode: Whether or not to use the platform driver.
 176 *
 177 * Use the platform driver to prepare the system for creating a hibernate image,
 178 * if so configured, and return an error code if that fails.
 179 */
 180
 181static int platform_pre_snapshot(int platform_mode)
 182{
 183	return (platform_mode && hibernation_ops) ?
 184		hibernation_ops->pre_snapshot() : 0;
 185}
 186
 187/**
 188 * platform_leave - Call platform to prepare a transition to the working state.
 189 * @platform_mode: Whether or not to use the platform driver.
 190 *
 191 * Use the platform driver prepare to prepare the machine for switching to the
 192 * normal mode of operation.
 193 *
 194 * This routine is called on one CPU with interrupts disabled.
 195 */
 196static void platform_leave(int platform_mode)
 197{
 198	if (platform_mode && hibernation_ops)
 199		hibernation_ops->leave();
 200}
 201
 202/**
 203 * platform_finish - Call platform to switch the system to the working state.
 204 * @platform_mode: Whether or not to use the platform driver.
 205 *
 206 * Use the platform driver to switch the machine to the normal mode of
 207 * operation.
 208 *
 209 * This routine must be called after platform_prepare().
 210 */
 211static void platform_finish(int platform_mode)
 212{
 213	if (platform_mode && hibernation_ops)
 214		hibernation_ops->finish();
 215}
 216
 217/**
 218 * platform_pre_restore - Prepare for hibernate image restoration.
 219 * @platform_mode: Whether or not to use the platform driver.
 220 *
 221 * Use the platform driver to prepare the system for resume from a hibernation
 222 * image.
 223 *
 224 * If the restore fails after this function has been called,
 225 * platform_restore_cleanup() must be called.
 226 */
 227static int platform_pre_restore(int platform_mode)
 228{
 229	return (platform_mode && hibernation_ops) ?
 230		hibernation_ops->pre_restore() : 0;
 231}
 232
 233/**
 234 * platform_restore_cleanup - Switch to the working state after failing restore.
 235 * @platform_mode: Whether or not to use the platform driver.
 236 *
 237 * Use the platform driver to switch the system to the normal mode of operation
 238 * after a failing restore.
 239 *
 240 * If platform_pre_restore() has been called before the failing restore, this
 241 * function must be called too, regardless of the result of
 242 * platform_pre_restore().
 243 */
 244static void platform_restore_cleanup(int platform_mode)
 245{
 246	if (platform_mode && hibernation_ops)
 247		hibernation_ops->restore_cleanup();
 248}
 249
 250/**
 251 * platform_recover - Recover from a failure to suspend devices.
 252 * @platform_mode: Whether or not to use the platform driver.
 253 */
 254static void platform_recover(int platform_mode)
 255{
 256	if (platform_mode && hibernation_ops && hibernation_ops->recover)
 257		hibernation_ops->recover();
 258}
 259
 260/**
 261 * swsusp_show_speed - Print time elapsed between two events during hibernation.
 262 * @start: Starting event.
 263 * @stop: Final event.
 264 * @nr_pages: Number of memory pages processed between @start and @stop.
 265 * @msg: Additional diagnostic message to print.
 266 */
 267void swsusp_show_speed(ktime_t start, ktime_t stop,
 268		      unsigned nr_pages, char *msg)
 269{
 270	ktime_t diff;
 271	u64 elapsed_centisecs64;
 272	unsigned int centisecs;
 273	unsigned int k;
 274	unsigned int kps;
 275
 276	diff = ktime_sub(stop, start);
 277	elapsed_centisecs64 = ktime_divns(diff, 10*NSEC_PER_MSEC);
 278	centisecs = elapsed_centisecs64;
 279	if (centisecs == 0)
 280		centisecs = 1;	/* avoid div-by-zero */
 281	k = nr_pages * (PAGE_SIZE / 1024);
 282	kps = (k * 100) / centisecs;
 283	pr_info("%s %u kbytes in %u.%02u seconds (%u.%02u MB/s)\n",
 284		msg, k, centisecs / 100, centisecs % 100, kps / 1000,
 285		(kps % 1000) / 10);
 286}
 287
 288__weak int arch_resume_nosmt(void)
 289{
 290	return 0;
 291}
 292
 293/**
 294 * create_image - Create a hibernation image.
 295 * @platform_mode: Whether or not to use the platform driver.
 296 *
 297 * Execute device drivers' "late" and "noirq" freeze callbacks, create a
 298 * hibernation image and run the drivers' "noirq" and "early" thaw callbacks.
 299 *
 300 * Control reappears in this routine after the subsequent restore.
 301 */
 302static int create_image(int platform_mode)
 303{
 304	int error;
 305
 306	error = dpm_suspend_end(PMSG_FREEZE);
 307	if (error) {
 308		pr_err("Some devices failed to power down, aborting\n");
 309		return error;
 310	}
 311
 312	error = platform_pre_snapshot(platform_mode);
 313	if (error || hibernation_test(TEST_PLATFORM))
 314		goto Platform_finish;
 315
 316	error = pm_sleep_disable_secondary_cpus();
 317	if (error || hibernation_test(TEST_CPUS))
 318		goto Enable_cpus;
 319
 320	local_irq_disable();
 321
 322	system_state = SYSTEM_SUSPEND;
 323
 324	error = syscore_suspend();
 325	if (error) {
 326		pr_err("Some system devices failed to power down, aborting\n");
 327		goto Enable_irqs;
 328	}
 329
 330	if (hibernation_test(TEST_CORE) || pm_wakeup_pending())
 331		goto Power_up;
 332
 333	in_suspend = 1;
 334	save_processor_state();
 335	trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, true);
 336	error = swsusp_arch_suspend();
 337	/* Restore control flow magically appears here */
 338	restore_processor_state();
 339	trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, false);
 340	if (error)
 341		pr_err("Error %d creating image\n", error);
 342
 343	if (!in_suspend) {
 344		events_check_enabled = false;
 345		clear_or_poison_free_pages();
 346	}
 347
 348	platform_leave(platform_mode);
 349
 350 Power_up:
 351	syscore_resume();
 352
 353 Enable_irqs:
 354	system_state = SYSTEM_RUNNING;
 355	local_irq_enable();
 356
 357 Enable_cpus:
 358	pm_sleep_enable_secondary_cpus();
 359
 360	/* Allow architectures to do nosmt-specific post-resume dances */
 361	if (!in_suspend)
 362		error = arch_resume_nosmt();
 363
 364 Platform_finish:
 365	platform_finish(platform_mode);
 366
 367	dpm_resume_start(in_suspend ?
 368		(error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
 369
 370	return error;
 371}
 372
 373/**
 374 * hibernation_snapshot - Quiesce devices and create a hibernation image.
 375 * @platform_mode: If set, use platform driver to prepare for the transition.
 376 *
 377 * This routine must be called with system_transition_mutex held.
 378 */
 379int hibernation_snapshot(int platform_mode)
 380{
 381	pm_message_t msg;
 382	int error;
 383
 384	pm_suspend_clear_flags();
 385	error = platform_begin(platform_mode);
 386	if (error)
 387		goto Close;
 388
 389	/* Preallocate image memory before shutting down devices. */
 390	error = hibernate_preallocate_memory();
 391	if (error)
 392		goto Close;
 393
 394	error = freeze_kernel_threads();
 395	if (error)
 396		goto Cleanup;
 397
 398	if (hibernation_test(TEST_FREEZER)) {
 399
 400		/*
 401		 * Indicate to the caller that we are returning due to a
 402		 * successful freezer test.
 403		 */
 404		freezer_test_done = true;
 405		goto Thaw;
 406	}
 407
 408	error = dpm_prepare(PMSG_FREEZE);
 409	if (error) {
 410		dpm_complete(PMSG_RECOVER);
 411		goto Thaw;
 412	}
 413
 414	suspend_console();
 415	pm_restrict_gfp_mask();
 416
 417	error = dpm_suspend(PMSG_FREEZE);
 418
 419	if (error || hibernation_test(TEST_DEVICES))
 420		platform_recover(platform_mode);
 421	else
 422		error = create_image(platform_mode);
 423
 424	/*
 425	 * In the case that we call create_image() above, the control
 426	 * returns here (1) after the image has been created or the
 427	 * image creation has failed and (2) after a successful restore.
 428	 */
 429
 430	/* We may need to release the preallocated image pages here. */
 431	if (error || !in_suspend)
 432		swsusp_free();
 433
 434	msg = in_suspend ? (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE;
 435	dpm_resume(msg);
 436
 437	if (error || !in_suspend)
 438		pm_restore_gfp_mask();
 439
 440	resume_console();
 441	dpm_complete(msg);
 442
 443 Close:
 444	platform_end(platform_mode);
 445	return error;
 446
 447 Thaw:
 448	thaw_kernel_threads();
 449 Cleanup:
 450	swsusp_free();
 451	goto Close;
 452}
 453
 454int __weak hibernate_resume_nonboot_cpu_disable(void)
 455{
 456	return suspend_disable_secondary_cpus();
 457}
 458
 459/**
 460 * resume_target_kernel - Restore system state from a hibernation image.
 461 * @platform_mode: Whether or not to use the platform driver.
 462 *
 463 * Execute device drivers' "noirq" and "late" freeze callbacks, restore the
 464 * contents of highmem that have not been restored yet from the image and run
 465 * the low-level code that will restore the remaining contents of memory and
 466 * switch to the just restored target kernel.
 467 */
 468static int resume_target_kernel(bool platform_mode)
 469{
 470	int error;
 471
 472	error = dpm_suspend_end(PMSG_QUIESCE);
 473	if (error) {
 474		pr_err("Some devices failed to power down, aborting resume\n");
 475		return error;
 476	}
 477
 478	error = platform_pre_restore(platform_mode);
 479	if (error)
 480		goto Cleanup;
 481
 482	cpuidle_pause();
 483
 484	error = hibernate_resume_nonboot_cpu_disable();
 485	if (error)
 486		goto Enable_cpus;
 487
 488	local_irq_disable();
 489	system_state = SYSTEM_SUSPEND;
 490
 491	error = syscore_suspend();
 492	if (error)
 493		goto Enable_irqs;
 494
 495	save_processor_state();
 496	error = restore_highmem();
 497	if (!error) {
 498		error = swsusp_arch_resume();
 499		/*
 500		 * The code below is only ever reached in case of a failure.
 501		 * Otherwise, execution continues at the place where
 502		 * swsusp_arch_suspend() was called.
 503		 */
 504		BUG_ON(!error);
 505		/*
 506		 * This call to restore_highmem() reverts the changes made by
 507		 * the previous one.
 508		 */
 509		restore_highmem();
 510	}
 511	/*
 512	 * The only reason why swsusp_arch_resume() can fail is memory being
 513	 * very tight, so we have to free it as soon as we can to avoid
 514	 * subsequent failures.
 515	 */
 516	swsusp_free();
 517	restore_processor_state();
 518	touch_softlockup_watchdog();
 519
 520	syscore_resume();
 521
 522 Enable_irqs:
 523	system_state = SYSTEM_RUNNING;
 524	local_irq_enable();
 525
 526 Enable_cpus:
 527	pm_sleep_enable_secondary_cpus();
 528
 529 Cleanup:
 530	platform_restore_cleanup(platform_mode);
 531
 532	dpm_resume_start(PMSG_RECOVER);
 533
 534	return error;
 535}
 536
 537/**
 538 * hibernation_restore - Quiesce devices and restore from a hibernation image.
 539 * @platform_mode: If set, use platform driver to prepare for the transition.
 540 *
 541 * This routine must be called with system_transition_mutex held.  If it is
 542 * successful, control reappears in the restored target kernel in
 543 * hibernation_snapshot().
 544 */
 545int hibernation_restore(int platform_mode)
 546{
 547	int error;
 548
 549	pm_prepare_console();
 550	suspend_console();
 551	pm_restrict_gfp_mask();
 552	error = dpm_suspend_start(PMSG_QUIESCE);
 553	if (!error) {
 554		error = resume_target_kernel(platform_mode);
 555		/*
 556		 * The above should either succeed and jump to the new kernel,
 557		 * or return with an error. Otherwise things are just
 558		 * undefined, so let's be paranoid.
 559		 */
 560		BUG_ON(!error);
 561	}
 562	dpm_resume_end(PMSG_RECOVER);
 563	pm_restore_gfp_mask();
 564	resume_console();
 565	pm_restore_console();
 566	return error;
 567}
 568
 569/**
 570 * hibernation_platform_enter - Power off the system using the platform driver.
 571 */
 572int hibernation_platform_enter(void)
 573{
 574	int error;
 575
 576	if (!hibernation_ops)
 577		return -ENOSYS;
 578
 579	/*
 580	 * We have cancelled the power transition by running
 581	 * hibernation_ops->finish() before saving the image, so we should let
 582	 * the firmware know that we're going to enter the sleep state after all
 583	 */
 584	error = hibernation_ops->begin(PMSG_HIBERNATE);
 585	if (error)
 586		goto Close;
 587
 588	entering_platform_hibernation = true;
 589	suspend_console();
 590	error = dpm_suspend_start(PMSG_HIBERNATE);
 591	if (error) {
 592		if (hibernation_ops->recover)
 593			hibernation_ops->recover();
 594		goto Resume_devices;
 595	}
 596
 597	error = dpm_suspend_end(PMSG_HIBERNATE);
 598	if (error)
 599		goto Resume_devices;
 600
 601	error = hibernation_ops->prepare();
 602	if (error)
 603		goto Platform_finish;
 604
 605	error = pm_sleep_disable_secondary_cpus();
 606	if (error)
 607		goto Enable_cpus;
 608
 609	local_irq_disable();
 610	system_state = SYSTEM_SUSPEND;
 611
 612	error = syscore_suspend();
 613	if (error)
 614		goto Enable_irqs;
 615
 616	if (pm_wakeup_pending()) {
 617		error = -EAGAIN;
 618		goto Power_up;
 619	}
 620
 621	hibernation_ops->enter();
 622	/* We should never get here */
 623	while (1);
 624
 625 Power_up:
 626	syscore_resume();
 627 Enable_irqs:
 628	system_state = SYSTEM_RUNNING;
 629	local_irq_enable();
 630
 631 Enable_cpus:
 632	pm_sleep_enable_secondary_cpus();
 633
 634 Platform_finish:
 635	hibernation_ops->finish();
 636
 637	dpm_resume_start(PMSG_RESTORE);
 638
 639 Resume_devices:
 640	entering_platform_hibernation = false;
 641	dpm_resume_end(PMSG_RESTORE);
 642	resume_console();
 643
 644 Close:
 645	hibernation_ops->end();
 646
 647	return error;
 648}
 649
 650/**
 651 * power_down - Shut the machine down for hibernation.
 652 *
 653 * Use the platform driver, if configured, to put the system into the sleep
 654 * state corresponding to hibernation, or try to power it off or reboot,
 655 * depending on the value of hibernation_mode.
 656 */
 657static void power_down(void)
 658{
 
 659	int error;
 660
 661#ifdef CONFIG_SUSPEND
 662	if (hibernation_mode == HIBERNATION_SUSPEND) {
 663		error = suspend_devices_and_enter(mem_sleep_current);
 664		if (error) {
 665			hibernation_mode = hibernation_ops ?
 666						HIBERNATION_PLATFORM :
 667						HIBERNATION_SHUTDOWN;
 668		} else {
 669			/* Restore swap signature. */
 670			error = swsusp_unmark();
 671			if (error)
 672				pr_err("Swap will be unusable! Try swapon -a.\n");
 673
 674			return;
 675		}
 676	}
 677#endif
 678
 679	switch (hibernation_mode) {
 680	case HIBERNATION_REBOOT:
 681		kernel_restart(NULL);
 682		break;
 683	case HIBERNATION_PLATFORM:
 684		error = hibernation_platform_enter();
 685		if (error == -EAGAIN || error == -EBUSY) {
 686			swsusp_unmark();
 687			events_check_enabled = false;
 688			pr_info("Wakeup event detected during hibernation, rolling back.\n");
 689			return;
 690		}
 691		fallthrough;
 692	case HIBERNATION_SHUTDOWN:
 693		if (kernel_can_power_off()) {
 694			entering_platform_hibernation = true;
 695			kernel_power_off();
 696			entering_platform_hibernation = false;
 697		}
 698		break;
 699	}
 700	kernel_halt();
 701	/*
 702	 * Valid image is on the disk, if we continue we risk serious data
 703	 * corruption after resume.
 704	 */
 705	pr_crit("Power down manually\n");
 706	while (1)
 707		cpu_relax();
 708}
 709
 710static int load_image_and_restore(void)
 711{
 712	int error;
 713	unsigned int flags;
 714
 715	pm_pr_dbg("Loading hibernation image.\n");
 716
 717	lock_device_hotplug();
 718	error = create_basic_memory_bitmaps();
 719	if (error) {
 720		swsusp_close();
 721		goto Unlock;
 722	}
 723
 724	error = swsusp_read(&flags);
 725	swsusp_close();
 726	if (!error)
 727		error = hibernation_restore(flags & SF_PLATFORM_MODE);
 728
 729	pr_err("Failed to load image, recovering.\n");
 730	swsusp_free();
 731	free_basic_memory_bitmaps();
 732 Unlock:
 733	unlock_device_hotplug();
 734
 735	return error;
 736}
 737
 738#define COMPRESSION_ALGO_LZO "lzo"
 739#define COMPRESSION_ALGO_LZ4 "lz4"
 740
 741/**
 742 * hibernate - Carry out system hibernation, including saving the image.
 743 */
 744int hibernate(void)
 745{
 
 746	bool snapshot_test = false;
 747	unsigned int sleep_flags;
 748	int error;
 749
 750	if (!hibernation_available()) {
 751		pm_pr_dbg("Hibernation not available.\n");
 752		return -EPERM;
 753	}
 754
 755	/*
 756	 * Query for the compression algorithm support if compression is enabled.
 757	 */
 758	if (!nocompress) {
 759		strscpy(hib_comp_algo, hibernate_compressor, sizeof(hib_comp_algo));
 760		if (crypto_has_comp(hib_comp_algo, 0, 0) != 1) {
 761			pr_err("%s compression is not available\n", hib_comp_algo);
 762			return -EOPNOTSUPP;
 763		}
 764	}
 765
 766	sleep_flags = lock_system_sleep();
 767	/* The snapshot device should not be opened while we're running */
 768	if (!hibernate_acquire()) {
 769		error = -EBUSY;
 770		goto Unlock;
 771	}
 772
 773	pr_info("hibernation entry\n");
 774	pm_prepare_console();
 775	error = pm_notifier_call_chain_robust(PM_HIBERNATION_PREPARE, PM_POST_HIBERNATION);
 776	if (error)
 777		goto Restore;
 
 
 778
 779	ksys_sync_helper();
 
 
 780
 781	error = freeze_processes();
 782	if (error)
 783		goto Exit;
 784
 785	lock_device_hotplug();
 786	/* Allocate memory management structures */
 787	error = create_basic_memory_bitmaps();
 788	if (error)
 789		goto Thaw;
 790
 791	error = hibernation_snapshot(hibernation_mode == HIBERNATION_PLATFORM);
 792	if (error || freezer_test_done)
 793		goto Free_bitmaps;
 794
 795	if (in_suspend) {
 796		unsigned int flags = 0;
 797
 798		if (hibernation_mode == HIBERNATION_PLATFORM)
 799			flags |= SF_PLATFORM_MODE;
 800		if (nocompress) {
 801			flags |= SF_NOCOMPRESS_MODE;
 802		} else {
 803		        flags |= SF_CRC32_MODE;
 804
 805			/*
 806			 * By default, LZO compression is enabled. Use SF_COMPRESSION_ALG_LZ4
 807			 * to override this behaviour and use LZ4.
 808			 *
 809			 * Refer kernel/power/power.h for more details
 810			 */
 811
 812			if (!strcmp(hib_comp_algo, COMPRESSION_ALGO_LZ4))
 813				flags |= SF_COMPRESSION_ALG_LZ4;
 814			else
 815				flags |= SF_COMPRESSION_ALG_LZO;
 816		}
 817
 818		pm_pr_dbg("Writing hibernation image.\n");
 819		error = swsusp_write(flags);
 820		swsusp_free();
 821		if (!error) {
 822			if (hibernation_mode == HIBERNATION_TEST_RESUME)
 823				snapshot_test = true;
 824			else
 825				power_down();
 826		}
 827		in_suspend = 0;
 828		pm_restore_gfp_mask();
 829	} else {
 830		pm_pr_dbg("Hibernation image restored successfully.\n");
 831	}
 832
 833 Free_bitmaps:
 834	free_basic_memory_bitmaps();
 835 Thaw:
 836	unlock_device_hotplug();
 837	if (snapshot_test) {
 838		pm_pr_dbg("Checking hibernation image\n");
 839		error = swsusp_check(false);
 840		if (!error)
 841			error = load_image_and_restore();
 842	}
 843	thaw_processes();
 844
 845	/* Don't bother checking whether freezer_test_done is true */
 846	freezer_test_done = false;
 847 Exit:
 848	pm_notifier_call_chain(PM_POST_HIBERNATION);
 849 Restore:
 850	pm_restore_console();
 851	hibernate_release();
 852 Unlock:
 853	unlock_system_sleep(sleep_flags);
 854	pr_info("hibernation exit\n");
 855
 856	return error;
 857}
 858
 
 859/**
 860 * hibernate_quiet_exec - Execute a function with all devices frozen.
 861 * @func: Function to execute.
 862 * @data: Data pointer to pass to @func.
 
 863 *
 864 * Return the @func return value or an error code if it cannot be executed.
 
 
 
 
 
 
 
 865 */
 866int hibernate_quiet_exec(int (*func)(void *data), void *data)
 867{
 868	unsigned int sleep_flags;
 869	int error;
 870
 871	sleep_flags = lock_system_sleep();
 
 
 
 
 872
 873	if (!hibernate_acquire()) {
 874		error = -EBUSY;
 875		goto unlock;
 876	}
 
 
 
 
 
 
 
 877
 878	pm_prepare_console();
 
 879
 880	error = pm_notifier_call_chain_robust(PM_HIBERNATION_PREPARE, PM_POST_HIBERNATION);
 881	if (error)
 882		goto restore;
 883
 884	error = freeze_processes();
 885	if (error)
 886		goto exit;
 887
 888	lock_device_hotplug();
 889
 890	pm_suspend_clear_flags();
 891
 892	error = platform_begin(true);
 893	if (error)
 894		goto thaw;
 895
 896	error = freeze_kernel_threads();
 897	if (error)
 898		goto thaw;
 899
 900	error = dpm_prepare(PMSG_FREEZE);
 901	if (error)
 902		goto dpm_complete;
 903
 904	suspend_console();
 905
 906	error = dpm_suspend(PMSG_FREEZE);
 907	if (error)
 908		goto dpm_resume;
 909
 910	error = dpm_suspend_end(PMSG_FREEZE);
 911	if (error)
 912		goto dpm_resume;
 913
 914	error = platform_pre_snapshot(true);
 915	if (error)
 916		goto skip;
 917
 918	error = func(data);
 919
 920skip:
 921	platform_finish(true);
 922
 923	dpm_resume_start(PMSG_THAW);
 924
 925dpm_resume:
 926	dpm_resume(PMSG_THAW);
 927
 928	resume_console();
 929
 930dpm_complete:
 931	dpm_complete(PMSG_THAW);
 932
 933	thaw_kernel_threads();
 934
 935thaw:
 936	platform_end(true);
 937
 938	unlock_device_hotplug();
 939
 940	thaw_processes();
 941
 942exit:
 943	pm_notifier_call_chain(PM_POST_HIBERNATION);
 944
 945restore:
 946	pm_restore_console();
 947
 948	hibernate_release();
 949
 950unlock:
 951	unlock_system_sleep(sleep_flags);
 952
 953	return error;
 954}
 955EXPORT_SYMBOL_GPL(hibernate_quiet_exec);
 956
 957static int __init find_resume_device(void)
 958{
 959	if (!strlen(resume_file))
 960		return -ENOENT;
 961
 962	pm_pr_dbg("Checking hibernation image partition %s\n", resume_file);
 963
 964	if (resume_delay) {
 965		pr_info("Waiting %dsec before reading resume device ...\n",
 966			resume_delay);
 967		ssleep(resume_delay);
 968	}
 969
 970	/* Check if the device is there */
 971	if (!early_lookup_bdev(resume_file, &swsusp_resume_device))
 972		return 0;
 973
 974	/*
 975	 * Some device discovery might still be in progress; we need to wait for
 976	 * this to finish.
 977	 */
 978	wait_for_device_probe();
 979	if (resume_wait) {
 980		while (early_lookup_bdev(resume_file, &swsusp_resume_device))
 981			msleep(10);
 982		async_synchronize_full();
 983	}
 984
 985	return early_lookup_bdev(resume_file, &swsusp_resume_device);
 986}
 
 
 
 
 
 
 
 
 
 
 987
 988static int software_resume(void)
 989{
 990	int error;
 
 
 
 991
 
 992	pm_pr_dbg("Hibernation image partition %d:%d present\n",
 993		MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
 994
 995	pm_pr_dbg("Looking for hibernation image.\n");
 996
 997	mutex_lock(&system_transition_mutex);
 998	error = swsusp_check(true);
 999	if (error)
1000		goto Unlock;
1001
1002	/*
1003	 * Check if the hibernation image is compressed. If so, query for
1004	 * the algorithm support.
1005	 */
1006	if (!(swsusp_header_flags & SF_NOCOMPRESS_MODE)) {
1007		if (swsusp_header_flags & SF_COMPRESSION_ALG_LZ4)
1008			strscpy(hib_comp_algo, COMPRESSION_ALGO_LZ4, sizeof(hib_comp_algo));
1009		else
1010			strscpy(hib_comp_algo, COMPRESSION_ALGO_LZO, sizeof(hib_comp_algo));
1011		if (crypto_has_comp(hib_comp_algo, 0, 0) != 1) {
1012			pr_err("%s compression is not available\n", hib_comp_algo);
1013			error = -EOPNOTSUPP;
1014			goto Unlock;
1015		}
1016	}
1017
1018	/* The snapshot device should not be opened while we're running */
1019	if (!hibernate_acquire()) {
1020		error = -EBUSY;
1021		swsusp_close();
1022		goto Unlock;
1023	}
1024
1025	pr_info("resume from hibernation\n");
1026	pm_prepare_console();
1027	error = pm_notifier_call_chain_robust(PM_RESTORE_PREPARE, PM_POST_RESTORE);
1028	if (error)
1029		goto Restore;
 
 
1030
1031	pm_pr_dbg("Preparing processes for hibernation restore.\n");
1032	error = freeze_processes();
1033	if (error)
1034		goto Close_Finish;
1035
1036	error = freeze_kernel_threads();
1037	if (error) {
1038		thaw_processes();
1039		goto Close_Finish;
1040	}
1041
1042	error = load_image_and_restore();
1043	thaw_processes();
1044 Finish:
1045	pm_notifier_call_chain(PM_POST_RESTORE);
1046 Restore:
1047	pm_restore_console();
1048	pr_info("resume failed (%d)\n", error);
1049	hibernate_release();
1050	/* For success case, the suspend path will release the lock */
1051 Unlock:
1052	mutex_unlock(&system_transition_mutex);
1053	pm_pr_dbg("Hibernation image not present or could not be loaded.\n");
1054	return error;
1055 Close_Finish:
1056	swsusp_close();
1057	goto Finish;
1058}
1059
1060/**
1061 * software_resume_initcall - Resume from a saved hibernation image.
1062 *
1063 * This routine is called as a late initcall, when all devices have been
1064 * discovered and initialized already.
1065 *
1066 * The image reading code is called to see if there is a hibernation image
1067 * available for reading.  If that is the case, devices are quiesced and the
1068 * contents of memory is restored from the saved image.
1069 *
1070 * If this is successful, control reappears in the restored target kernel in
1071 * hibernation_snapshot() which returns to hibernate().  Otherwise, the routine
1072 * attempts to recover gracefully and make the kernel return to the normal mode
1073 * of operation.
1074 */
1075static int __init software_resume_initcall(void)
1076{
1077	/*
1078	 * If the user said "noresume".. bail out early.
1079	 */
1080	if (noresume || !hibernation_available())
1081		return 0;
1082
1083	if (!swsusp_resume_device) {
1084		int error = find_resume_device();
1085
1086		if (error)
1087			return error;
1088	}
1089
1090	return software_resume();
1091}
1092late_initcall_sync(software_resume_initcall);
1093
1094
1095static const char * const hibernation_modes[] = {
1096	[HIBERNATION_PLATFORM]	= "platform",
1097	[HIBERNATION_SHUTDOWN]	= "shutdown",
1098	[HIBERNATION_REBOOT]	= "reboot",
1099#ifdef CONFIG_SUSPEND
1100	[HIBERNATION_SUSPEND]	= "suspend",
1101#endif
1102	[HIBERNATION_TEST_RESUME]	= "test_resume",
1103};
1104
1105/*
1106 * /sys/power/disk - Control hibernation mode.
1107 *
1108 * Hibernation can be handled in several ways.  There are a few different ways
1109 * to put the system into the sleep state: using the platform driver (e.g. ACPI
1110 * or other hibernation_ops), powering it off or rebooting it (for testing
1111 * mostly).
1112 *
1113 * The sysfs file /sys/power/disk provides an interface for selecting the
1114 * hibernation mode to use.  Reading from this file causes the available modes
1115 * to be printed.  There are 3 modes that can be supported:
1116 *
1117 *	'platform'
1118 *	'shutdown'
1119 *	'reboot'
1120 *
1121 * If a platform hibernation driver is in use, 'platform' will be supported
1122 * and will be used by default.  Otherwise, 'shutdown' will be used by default.
1123 * The selected option (i.e. the one corresponding to the current value of
1124 * hibernation_mode) is enclosed by a square bracket.
1125 *
1126 * To select a given hibernation mode it is necessary to write the mode's
1127 * string representation (as returned by reading from /sys/power/disk) back
1128 * into /sys/power/disk.
1129 */
1130
1131static ssize_t disk_show(struct kobject *kobj, struct kobj_attribute *attr,
1132			 char *buf)
1133{
1134	ssize_t count = 0;
1135	int i;
 
1136
1137	if (!hibernation_available())
1138		return sysfs_emit(buf, "[disabled]\n");
1139
1140	for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
1141		if (!hibernation_modes[i])
1142			continue;
1143		switch (i) {
1144		case HIBERNATION_SHUTDOWN:
1145		case HIBERNATION_REBOOT:
1146#ifdef CONFIG_SUSPEND
1147		case HIBERNATION_SUSPEND:
1148#endif
1149		case HIBERNATION_TEST_RESUME:
1150			break;
1151		case HIBERNATION_PLATFORM:
1152			if (hibernation_ops)
1153				break;
1154			/* not a valid mode, continue with loop */
1155			continue;
1156		}
1157		if (i == hibernation_mode)
1158			count += sysfs_emit_at(buf, count, "[%s] ", hibernation_modes[i]);
1159		else
1160			count += sysfs_emit_at(buf, count, "%s ", hibernation_modes[i]);
1161	}
1162
1163	/* Convert the last space to a newline if needed. */
1164	if (count > 0)
1165		buf[count - 1] = '\n';
1166
1167	return count;
1168}
1169
1170static ssize_t disk_store(struct kobject *kobj, struct kobj_attribute *attr,
1171			  const char *buf, size_t n)
1172{
1173	int mode = HIBERNATION_INVALID;
1174	unsigned int sleep_flags;
1175	int error = 0;
 
1176	int len;
1177	char *p;
1178	int i;
1179
1180	if (!hibernation_available())
1181		return -EPERM;
1182
1183	p = memchr(buf, '\n', n);
1184	len = p ? p - buf : n;
1185
1186	sleep_flags = lock_system_sleep();
1187	for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
1188		if (len == strlen(hibernation_modes[i])
1189		    && !strncmp(buf, hibernation_modes[i], len)) {
1190			mode = i;
1191			break;
1192		}
1193	}
1194	if (mode != HIBERNATION_INVALID) {
1195		switch (mode) {
1196		case HIBERNATION_SHUTDOWN:
1197		case HIBERNATION_REBOOT:
1198#ifdef CONFIG_SUSPEND
1199		case HIBERNATION_SUSPEND:
1200#endif
1201		case HIBERNATION_TEST_RESUME:
1202			hibernation_mode = mode;
1203			break;
1204		case HIBERNATION_PLATFORM:
1205			if (hibernation_ops)
1206				hibernation_mode = mode;
1207			else
1208				error = -EINVAL;
1209		}
1210	} else
1211		error = -EINVAL;
1212
1213	if (!error)
1214		pm_pr_dbg("Hibernation mode set to '%s'\n",
1215			       hibernation_modes[mode]);
1216	unlock_system_sleep(sleep_flags);
1217	return error ? error : n;
1218}
1219
1220power_attr(disk);
1221
1222static ssize_t resume_show(struct kobject *kobj, struct kobj_attribute *attr,
1223			   char *buf)
1224{
1225	return sysfs_emit(buf, "%d:%d\n", MAJOR(swsusp_resume_device),
1226			  MINOR(swsusp_resume_device));
1227}
1228
1229static ssize_t resume_store(struct kobject *kobj, struct kobj_attribute *attr,
1230			    const char *buf, size_t n)
1231{
1232	unsigned int sleep_flags;
1233	int len = n;
1234	char *name;
1235	dev_t dev;
1236	int error;
1237
1238	if (!hibernation_available())
1239		return n;
1240
1241	if (len && buf[len-1] == '\n')
1242		len--;
1243	name = kstrndup(buf, len, GFP_KERNEL);
1244	if (!name)
1245		return -ENOMEM;
1246
1247	error = lookup_bdev(name, &dev);
1248	if (error) {
1249		unsigned maj, min, offset;
1250		char *p, dummy;
1251
1252		error = 0;
1253		if (sscanf(name, "%u:%u%c", &maj, &min, &dummy) == 2 ||
1254		    sscanf(name, "%u:%u:%u:%c", &maj, &min, &offset,
1255				&dummy) == 3) {
1256			dev = MKDEV(maj, min);
1257			if (maj != MAJOR(dev) || min != MINOR(dev))
1258				error = -EINVAL;
1259		} else {
1260			dev = new_decode_dev(simple_strtoul(name, &p, 16));
1261			if (*p)
1262				error = -EINVAL;
1263		}
1264	}
1265	kfree(name);
1266	if (error)
1267		return error;
1268
1269	sleep_flags = lock_system_sleep();
1270	swsusp_resume_device = dev;
1271	unlock_system_sleep(sleep_flags);
1272
1273	pm_pr_dbg("Configured hibernation resume from disk to %u\n",
1274		  swsusp_resume_device);
1275	noresume = 0;
1276	software_resume();
1277	return n;
1278}
1279
1280power_attr(resume);
1281
1282static ssize_t resume_offset_show(struct kobject *kobj,
1283				  struct kobj_attribute *attr, char *buf)
1284{
1285	return sysfs_emit(buf, "%llu\n", (unsigned long long)swsusp_resume_block);
1286}
1287
1288static ssize_t resume_offset_store(struct kobject *kobj,
1289				   struct kobj_attribute *attr, const char *buf,
1290				   size_t n)
1291{
1292	unsigned long long offset;
1293	int rc;
1294
1295	rc = kstrtoull(buf, 0, &offset);
1296	if (rc)
1297		return rc;
1298	swsusp_resume_block = offset;
1299
1300	return n;
1301}
1302
1303power_attr(resume_offset);
1304
1305static ssize_t image_size_show(struct kobject *kobj, struct kobj_attribute *attr,
1306			       char *buf)
1307{
1308	return sysfs_emit(buf, "%lu\n", image_size);
1309}
1310
1311static ssize_t image_size_store(struct kobject *kobj, struct kobj_attribute *attr,
1312				const char *buf, size_t n)
1313{
1314	unsigned long size;
1315
1316	if (sscanf(buf, "%lu", &size) == 1) {
1317		image_size = size;
1318		return n;
1319	}
1320
1321	return -EINVAL;
1322}
1323
1324power_attr(image_size);
1325
1326static ssize_t reserved_size_show(struct kobject *kobj,
1327				  struct kobj_attribute *attr, char *buf)
1328{
1329	return sysfs_emit(buf, "%lu\n", reserved_size);
1330}
1331
1332static ssize_t reserved_size_store(struct kobject *kobj,
1333				   struct kobj_attribute *attr,
1334				   const char *buf, size_t n)
1335{
1336	unsigned long size;
1337
1338	if (sscanf(buf, "%lu", &size) == 1) {
1339		reserved_size = size;
1340		return n;
1341	}
1342
1343	return -EINVAL;
1344}
1345
1346power_attr(reserved_size);
1347
1348static struct attribute *g[] = {
1349	&disk_attr.attr,
1350	&resume_offset_attr.attr,
1351	&resume_attr.attr,
1352	&image_size_attr.attr,
1353	&reserved_size_attr.attr,
1354	NULL,
1355};
1356
1357
1358static const struct attribute_group attr_group = {
1359	.attrs = g,
1360};
1361
1362
1363static int __init pm_disk_init(void)
1364{
1365	return sysfs_create_group(power_kobj, &attr_group);
1366}
1367
1368core_initcall(pm_disk_init);
1369
1370
1371static int __init resume_setup(char *str)
1372{
1373	if (noresume)
1374		return 1;
1375
1376	strscpy(resume_file, str);
1377	return 1;
1378}
1379
1380static int __init resume_offset_setup(char *str)
1381{
1382	unsigned long long offset;
1383
1384	if (noresume)
1385		return 1;
1386
1387	if (sscanf(str, "%llu", &offset) == 1)
1388		swsusp_resume_block = offset;
1389
1390	return 1;
1391}
1392
1393static int __init hibernate_setup(char *str)
1394{
1395	if (!strncmp(str, "noresume", 8)) {
1396		noresume = 1;
1397	} else if (!strncmp(str, "nocompress", 10)) {
1398		nocompress = 1;
1399	} else if (!strncmp(str, "no", 2)) {
1400		noresume = 1;
1401		nohibernate = 1;
1402	} else if (IS_ENABLED(CONFIG_STRICT_KERNEL_RWX)
1403		   && !strncmp(str, "protect_image", 13)) {
1404		enable_restore_image_protection();
1405	}
1406	return 1;
1407}
1408
1409static int __init noresume_setup(char *str)
1410{
1411	noresume = 1;
1412	return 1;
1413}
1414
1415static int __init resumewait_setup(char *str)
1416{
1417	resume_wait = 1;
1418	return 1;
1419}
1420
1421static int __init resumedelay_setup(char *str)
1422{
1423	int rc = kstrtouint(str, 0, &resume_delay);
1424
1425	if (rc)
1426		pr_warn("resumedelay: bad option string '%s'\n", str);
1427	return 1;
1428}
1429
1430static int __init nohibernate_setup(char *str)
1431{
1432	noresume = 1;
1433	nohibernate = 1;
1434	return 1;
1435}
1436
1437static const char * const comp_alg_enabled[] = {
1438#if IS_ENABLED(CONFIG_CRYPTO_LZO)
1439	COMPRESSION_ALGO_LZO,
1440#endif
1441#if IS_ENABLED(CONFIG_CRYPTO_LZ4)
1442	COMPRESSION_ALGO_LZ4,
1443#endif
1444};
1445
1446static int hibernate_compressor_param_set(const char *compressor,
1447		const struct kernel_param *kp)
1448{
1449	unsigned int sleep_flags;
1450	int index, ret;
1451
1452	sleep_flags = lock_system_sleep();
1453
1454	index = sysfs_match_string(comp_alg_enabled, compressor);
1455	if (index >= 0) {
1456		ret = param_set_copystring(comp_alg_enabled[index], kp);
1457		if (!ret)
1458			strscpy(hib_comp_algo, comp_alg_enabled[index],
1459				sizeof(hib_comp_algo));
1460	} else {
1461		ret = index;
1462	}
1463
1464	unlock_system_sleep(sleep_flags);
1465
1466	if (ret)
1467		pr_debug("Cannot set specified compressor %s\n",
1468			 compressor);
1469
1470	return ret;
1471}
1472
1473static const struct kernel_param_ops hibernate_compressor_param_ops = {
1474	.set    = hibernate_compressor_param_set,
1475	.get    = param_get_string,
1476};
1477
1478static struct kparam_string hibernate_compressor_param_string = {
1479	.maxlen = sizeof(hibernate_compressor),
1480	.string = hibernate_compressor,
1481};
1482
1483module_param_cb(compressor, &hibernate_compressor_param_ops,
1484		&hibernate_compressor_param_string, 0644);
1485MODULE_PARM_DESC(compressor,
1486		 "Compression algorithm to be used with hibernation");
1487
1488__setup("noresume", noresume_setup);
1489__setup("resume_offset=", resume_offset_setup);
1490__setup("resume=", resume_setup);
1491__setup("hibernate=", hibernate_setup);
1492__setup("resumewait", resumewait_setup);
1493__setup("resumedelay=", resumedelay_setup);
1494__setup("nohibernate", nohibernate_setup);