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 *
   9 * This file is released under the GPLv2.
  10 */
  11
 
 
 
  12#include <linux/export.h>
  13#include <linux/suspend.h>
  14#include <linux/syscalls.h>
  15#include <linux/reboot.h>
  16#include <linux/string.h>
  17#include <linux/device.h>
  18#include <linux/async.h>
  19#include <linux/delay.h>
  20#include <linux/fs.h>
  21#include <linux/mount.h>
  22#include <linux/pm.h>
 
  23#include <linux/console.h>
  24#include <linux/cpu.h>
  25#include <linux/freezer.h>
  26#include <linux/gfp.h>
  27#include <linux/syscore_ops.h>
  28#include <linux/ctype.h>
  29#include <linux/genhd.h>
 
 
 
  30
  31#include "power.h"
  32
  33
  34static int nocompress;
  35static int noresume;
 
  36static int resume_wait;
  37static int resume_delay;
  38static char resume_file[256] = CONFIG_PM_STD_PARTITION;
  39dev_t swsusp_resume_device;
  40sector_t swsusp_resume_block;
  41int in_suspend __nosavedata;
 
 
 
 
 
 
 
 
 
  42
  43enum {
  44	HIBERNATION_INVALID,
  45	HIBERNATION_PLATFORM,
  46	HIBERNATION_SHUTDOWN,
  47	HIBERNATION_REBOOT,
 
 
 
 
  48	/* keep last */
  49	__HIBERNATION_AFTER_LAST
  50};
  51#define HIBERNATION_MAX (__HIBERNATION_AFTER_LAST-1)
  52#define HIBERNATION_FIRST (HIBERNATION_INVALID + 1)
  53
  54static int hibernation_mode = HIBERNATION_SHUTDOWN;
  55
  56bool freezer_test_done;
  57
  58static const struct platform_hibernation_ops *hibernation_ops;
  59
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  60/**
  61 * hibernation_set_ops - Set the global hibernate operations.
  62 * @ops: Hibernation operations to use in subsequent hibernation transitions.
  63 */
  64void hibernation_set_ops(const struct platform_hibernation_ops *ops)
  65{
 
 
  66	if (ops && !(ops->begin && ops->end &&  ops->pre_snapshot
  67	    && ops->prepare && ops->finish && ops->enter && ops->pre_restore
  68	    && ops->restore_cleanup && ops->leave)) {
  69		WARN_ON(1);
  70		return;
  71	}
  72	lock_system_sleep();
 
 
  73	hibernation_ops = ops;
  74	if (ops)
  75		hibernation_mode = HIBERNATION_PLATFORM;
  76	else if (hibernation_mode == HIBERNATION_PLATFORM)
  77		hibernation_mode = HIBERNATION_SHUTDOWN;
  78
  79	unlock_system_sleep();
  80}
 
  81
  82static bool entering_platform_hibernation;
  83
  84bool system_entering_hibernation(void)
  85{
  86	return entering_platform_hibernation;
  87}
  88EXPORT_SYMBOL(system_entering_hibernation);
  89
  90#ifdef CONFIG_PM_DEBUG
  91static void hibernation_debug_sleep(void)
  92{
  93	printk(KERN_INFO "hibernation debug: Waiting for 5 seconds.\n");
  94	mdelay(5000);
  95}
  96
  97static int hibernation_test(int level)
  98{
  99	if (pm_test_level == level) {
 100		hibernation_debug_sleep();
 101		return 1;
 102	}
 103	return 0;
 104}
 105#else /* !CONFIG_PM_DEBUG */
 106static int hibernation_test(int level) { return 0; }
 107#endif /* !CONFIG_PM_DEBUG */
 108
 109/**
 110 * platform_begin - Call platform to start hibernation.
 111 * @platform_mode: Whether or not to use the platform driver.
 112 */
 113static int platform_begin(int platform_mode)
 114{
 115	return (platform_mode && hibernation_ops) ?
 116		hibernation_ops->begin() : 0;
 117}
 118
 119/**
 120 * platform_end - Call platform to finish transition to the working state.
 121 * @platform_mode: Whether or not to use the platform driver.
 122 */
 123static void platform_end(int platform_mode)
 124{
 125	if (platform_mode && hibernation_ops)
 126		hibernation_ops->end();
 127}
 128
 129/**
 130 * platform_pre_snapshot - Call platform to prepare the machine for hibernation.
 131 * @platform_mode: Whether or not to use the platform driver.
 132 *
 133 * Use the platform driver to prepare the system for creating a hibernate image,
 134 * if so configured, and return an error code if that fails.
 135 */
 136
 137static int platform_pre_snapshot(int platform_mode)
 138{
 139	return (platform_mode && hibernation_ops) ?
 140		hibernation_ops->pre_snapshot() : 0;
 141}
 142
 143/**
 144 * platform_leave - Call platform to prepare a transition to the working state.
 145 * @platform_mode: Whether or not to use the platform driver.
 146 *
 147 * Use the platform driver prepare to prepare the machine for switching to the
 148 * normal mode of operation.
 149 *
 150 * This routine is called on one CPU with interrupts disabled.
 151 */
 152static void platform_leave(int platform_mode)
 153{
 154	if (platform_mode && hibernation_ops)
 155		hibernation_ops->leave();
 156}
 157
 158/**
 159 * platform_finish - Call platform to switch the system to the working state.
 160 * @platform_mode: Whether or not to use the platform driver.
 161 *
 162 * Use the platform driver to switch the machine to the normal mode of
 163 * operation.
 164 *
 165 * This routine must be called after platform_prepare().
 166 */
 167static void platform_finish(int platform_mode)
 168{
 169	if (platform_mode && hibernation_ops)
 170		hibernation_ops->finish();
 171}
 172
 173/**
 174 * platform_pre_restore - Prepare for hibernate image restoration.
 175 * @platform_mode: Whether or not to use the platform driver.
 176 *
 177 * Use the platform driver to prepare the system for resume from a hibernation
 178 * image.
 179 *
 180 * If the restore fails after this function has been called,
 181 * platform_restore_cleanup() must be called.
 182 */
 183static int platform_pre_restore(int platform_mode)
 184{
 185	return (platform_mode && hibernation_ops) ?
 186		hibernation_ops->pre_restore() : 0;
 187}
 188
 189/**
 190 * platform_restore_cleanup - Switch to the working state after failing restore.
 191 * @platform_mode: Whether or not to use the platform driver.
 192 *
 193 * Use the platform driver to switch the system to the normal mode of operation
 194 * after a failing restore.
 195 *
 196 * If platform_pre_restore() has been called before the failing restore, this
 197 * function must be called too, regardless of the result of
 198 * platform_pre_restore().
 199 */
 200static void platform_restore_cleanup(int platform_mode)
 201{
 202	if (platform_mode && hibernation_ops)
 203		hibernation_ops->restore_cleanup();
 204}
 205
 206/**
 207 * platform_recover - Recover from a failure to suspend devices.
 208 * @platform_mode: Whether or not to use the platform driver.
 209 */
 210static void platform_recover(int platform_mode)
 211{
 212	if (platform_mode && hibernation_ops && hibernation_ops->recover)
 213		hibernation_ops->recover();
 214}
 215
 216/**
 217 * swsusp_show_speed - Print time elapsed between two events during hibernation.
 218 * @start: Starting event.
 219 * @stop: Final event.
 220 * @nr_pages: Number of memory pages processed between @start and @stop.
 221 * @msg: Additional diagnostic message to print.
 222 */
 223void swsusp_show_speed(struct timeval *start, struct timeval *stop,
 224			unsigned nr_pages, char *msg)
 225{
 226	s64 elapsed_centisecs64;
 227	int centisecs;
 228	int k;
 229	int kps;
 
 230
 231	elapsed_centisecs64 = timeval_to_ns(stop) - timeval_to_ns(start);
 232	do_div(elapsed_centisecs64, NSEC_PER_SEC / 100);
 233	centisecs = elapsed_centisecs64;
 234	if (centisecs == 0)
 235		centisecs = 1;	/* avoid div-by-zero */
 236	k = nr_pages * (PAGE_SIZE / 1024);
 237	kps = (k * 100) / centisecs;
 238	printk(KERN_INFO "PM: %s %d kbytes in %d.%02d seconds (%d.%02d MB/s)\n",
 239			msg, k,
 240			centisecs / 100, centisecs % 100,
 241			kps / 1000, (kps % 1000) / 10);
 
 
 
 
 242}
 243
 244/**
 245 * create_image - Create a hibernation image.
 246 * @platform_mode: Whether or not to use the platform driver.
 247 *
 248 * Execute device drivers' "late" and "noirq" freeze callbacks, create a
 249 * hibernation image and run the drivers' "noirq" and "early" thaw callbacks.
 250 *
 251 * Control reappears in this routine after the subsequent restore.
 252 */
 253static int create_image(int platform_mode)
 254{
 255	int error;
 256
 257	error = dpm_suspend_end(PMSG_FREEZE);
 258	if (error) {
 259		printk(KERN_ERR "PM: Some devices failed to power down, "
 260			"aborting hibernation\n");
 261		return error;
 262	}
 263
 264	error = platform_pre_snapshot(platform_mode);
 265	if (error || hibernation_test(TEST_PLATFORM))
 266		goto Platform_finish;
 267
 268	error = disable_nonboot_cpus();
 269	if (error || hibernation_test(TEST_CPUS))
 270		goto Enable_cpus;
 271
 272	local_irq_disable();
 273
 
 
 274	error = syscore_suspend();
 275	if (error) {
 276		printk(KERN_ERR "PM: Some system devices failed to power down, "
 277			"aborting hibernation\n");
 278		goto Enable_irqs;
 279	}
 280
 281	if (hibernation_test(TEST_CORE) || pm_wakeup_pending())
 282		goto Power_up;
 283
 284	in_suspend = 1;
 285	save_processor_state();
 
 286	error = swsusp_arch_suspend();
 287	if (error)
 288		printk(KERN_ERR "PM: Error %d creating hibernation image\n",
 289			error);
 290	/* Restore control flow magically appears here */
 291	restore_processor_state();
 
 
 
 
 292	if (!in_suspend) {
 293		events_check_enabled = false;
 294		platform_leave(platform_mode);
 295	}
 296
 
 
 297 Power_up:
 298	syscore_resume();
 299
 300 Enable_irqs:
 
 301	local_irq_enable();
 302
 303 Enable_cpus:
 304	enable_nonboot_cpus();
 
 
 
 
 305
 306 Platform_finish:
 307	platform_finish(platform_mode);
 308
 309	dpm_resume_start(in_suspend ?
 310		(error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
 311
 312	return error;
 313}
 314
 315/**
 316 * hibernation_snapshot - Quiesce devices and create a hibernation image.
 317 * @platform_mode: If set, use platform driver to prepare for the transition.
 318 *
 319 * This routine must be called with pm_mutex held.
 320 */
 321int hibernation_snapshot(int platform_mode)
 322{
 323	pm_message_t msg;
 324	int error;
 325
 
 326	error = platform_begin(platform_mode);
 327	if (error)
 328		goto Close;
 329
 330	/* Preallocate image memory before shutting down devices. */
 331	error = hibernate_preallocate_memory();
 332	if (error)
 333		goto Close;
 334
 335	error = freeze_kernel_threads();
 336	if (error)
 337		goto Cleanup;
 338
 339	if (hibernation_test(TEST_FREEZER)) {
 340
 341		/*
 342		 * Indicate to the caller that we are returning due to a
 343		 * successful freezer test.
 344		 */
 345		freezer_test_done = true;
 346		goto Thaw;
 347	}
 348
 349	error = dpm_prepare(PMSG_FREEZE);
 350	if (error) {
 351		dpm_complete(PMSG_RECOVER);
 352		goto Thaw;
 353	}
 354
 355	suspend_console();
 356	ftrace_stop();
 357	pm_restrict_gfp_mask();
 358
 359	error = dpm_suspend(PMSG_FREEZE);
 360
 361	if (error || hibernation_test(TEST_DEVICES))
 362		platform_recover(platform_mode);
 363	else
 364		error = create_image(platform_mode);
 365
 366	/*
 367	 * In the case that we call create_image() above, the control
 368	 * returns here (1) after the image has been created or the
 369	 * image creation has failed and (2) after a successful restore.
 370	 */
 371
 372	/* We may need to release the preallocated image pages here. */
 373	if (error || !in_suspend)
 374		swsusp_free();
 375
 376	msg = in_suspend ? (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE;
 377	dpm_resume(msg);
 378
 379	if (error || !in_suspend)
 380		pm_restore_gfp_mask();
 381
 382	ftrace_start();
 383	resume_console();
 384	dpm_complete(msg);
 385
 386 Close:
 387	platform_end(platform_mode);
 388	return error;
 389
 390 Thaw:
 391	thaw_kernel_threads();
 392 Cleanup:
 393	swsusp_free();
 394	goto Close;
 395}
 396
 
 
 
 
 
 397/**
 398 * resume_target_kernel - Restore system state from a hibernation image.
 399 * @platform_mode: Whether or not to use the platform driver.
 400 *
 401 * Execute device drivers' "noirq" and "late" freeze callbacks, restore the
 402 * contents of highmem that have not been restored yet from the image and run
 403 * the low-level code that will restore the remaining contents of memory and
 404 * switch to the just restored target kernel.
 405 */
 406static int resume_target_kernel(bool platform_mode)
 407{
 408	int error;
 409
 410	error = dpm_suspend_end(PMSG_QUIESCE);
 411	if (error) {
 412		printk(KERN_ERR "PM: Some devices failed to power down, "
 413			"aborting resume\n");
 414		return error;
 415	}
 416
 417	error = platform_pre_restore(platform_mode);
 418	if (error)
 419		goto Cleanup;
 420
 421	error = disable_nonboot_cpus();
 
 
 422	if (error)
 423		goto Enable_cpus;
 424
 425	local_irq_disable();
 
 426
 427	error = syscore_suspend();
 428	if (error)
 429		goto Enable_irqs;
 430
 431	save_processor_state();
 432	error = restore_highmem();
 433	if (!error) {
 434		error = swsusp_arch_resume();
 435		/*
 436		 * The code below is only ever reached in case of a failure.
 437		 * Otherwise, execution continues at the place where
 438		 * swsusp_arch_suspend() was called.
 439		 */
 440		BUG_ON(!error);
 441		/*
 442		 * This call to restore_highmem() reverts the changes made by
 443		 * the previous one.
 444		 */
 445		restore_highmem();
 446	}
 447	/*
 448	 * The only reason why swsusp_arch_resume() can fail is memory being
 449	 * very tight, so we have to free it as soon as we can to avoid
 450	 * subsequent failures.
 451	 */
 452	swsusp_free();
 453	restore_processor_state();
 454	touch_softlockup_watchdog();
 455
 456	syscore_resume();
 457
 458 Enable_irqs:
 
 459	local_irq_enable();
 460
 461 Enable_cpus:
 462	enable_nonboot_cpus();
 463
 464 Cleanup:
 465	platform_restore_cleanup(platform_mode);
 466
 467	dpm_resume_start(PMSG_RECOVER);
 468
 469	return error;
 470}
 471
 472/**
 473 * hibernation_restore - Quiesce devices and restore from a hibernation image.
 474 * @platform_mode: If set, use platform driver to prepare for the transition.
 475 *
 476 * This routine must be called with pm_mutex held.  If it is successful, control
 477 * reappears in the restored target kernel in hibernation_snapshot().
 
 478 */
 479int hibernation_restore(int platform_mode)
 480{
 481	int error;
 482
 483	pm_prepare_console();
 484	suspend_console();
 485	ftrace_stop();
 486	pm_restrict_gfp_mask();
 487	error = dpm_suspend_start(PMSG_QUIESCE);
 488	if (!error) {
 489		error = resume_target_kernel(platform_mode);
 490		dpm_resume_end(PMSG_RECOVER);
 
 
 
 
 
 491	}
 
 492	pm_restore_gfp_mask();
 493	ftrace_start();
 494	resume_console();
 495	pm_restore_console();
 496	return error;
 497}
 498
 499/**
 500 * hibernation_platform_enter - Power off the system using the platform driver.
 501 */
 502int hibernation_platform_enter(void)
 503{
 504	int error;
 505
 506	if (!hibernation_ops)
 507		return -ENOSYS;
 508
 509	/*
 510	 * We have cancelled the power transition by running
 511	 * hibernation_ops->finish() before saving the image, so we should let
 512	 * the firmware know that we're going to enter the sleep state after all
 513	 */
 514	error = hibernation_ops->begin();
 515	if (error)
 516		goto Close;
 517
 518	entering_platform_hibernation = true;
 519	suspend_console();
 520	ftrace_stop();
 521	error = dpm_suspend_start(PMSG_HIBERNATE);
 522	if (error) {
 523		if (hibernation_ops->recover)
 524			hibernation_ops->recover();
 525		goto Resume_devices;
 526	}
 527
 528	error = dpm_suspend_end(PMSG_HIBERNATE);
 529	if (error)
 530		goto Resume_devices;
 531
 532	error = hibernation_ops->prepare();
 533	if (error)
 534		goto Platform_finish;
 535
 536	error = disable_nonboot_cpus();
 537	if (error)
 538		goto Platform_finish;
 539
 540	local_irq_disable();
 541	syscore_suspend();
 
 
 
 
 
 542	if (pm_wakeup_pending()) {
 543		error = -EAGAIN;
 544		goto Power_up;
 545	}
 546
 547	hibernation_ops->enter();
 548	/* We should never get here */
 549	while (1);
 550
 551 Power_up:
 552	syscore_resume();
 
 
 553	local_irq_enable();
 554	enable_nonboot_cpus();
 
 
 555
 556 Platform_finish:
 557	hibernation_ops->finish();
 558
 559	dpm_resume_start(PMSG_RESTORE);
 560
 561 Resume_devices:
 562	entering_platform_hibernation = false;
 563	dpm_resume_end(PMSG_RESTORE);
 564	ftrace_start();
 565	resume_console();
 566
 567 Close:
 568	hibernation_ops->end();
 569
 570	return error;
 571}
 572
 573/**
 574 * power_down - Shut the machine down for hibernation.
 575 *
 576 * Use the platform driver, if configured, to put the system into the sleep
 577 * state corresponding to hibernation, or try to power it off or reboot,
 578 * depending on the value of hibernation_mode.
 579 */
 580static void power_down(void)
 581{
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 582	switch (hibernation_mode) {
 583	case HIBERNATION_REBOOT:
 584		kernel_restart(NULL);
 585		break;
 586	case HIBERNATION_PLATFORM:
 587		hibernation_platform_enter();
 
 
 
 
 
 
 
 588	case HIBERNATION_SHUTDOWN:
 589		kernel_power_off();
 
 
 
 
 590		break;
 591	}
 592	kernel_halt();
 593	/*
 594	 * Valid image is on the disk, if we continue we risk serious data
 595	 * corruption after resume.
 596	 */
 597	printk(KERN_CRIT "PM: Please power down manually\n");
 598	while(1);
 
 599}
 600
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 601/**
 602 * hibernate - Carry out system hibernation, including saving the image.
 603 */
 604int hibernate(void)
 605{
 
 
 606	int error;
 607
 608	lock_system_sleep();
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 609	/* The snapshot device should not be opened while we're running */
 610	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
 611		error = -EBUSY;
 612		goto Unlock;
 613	}
 614
 
 615	pm_prepare_console();
 616	error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
 617	if (error)
 618		goto Exit;
 619
 620	/* Allocate memory management structures */
 621	error = create_basic_memory_bitmaps();
 
 622	if (error)
 623		goto Exit;
 624
 625	printk(KERN_INFO "PM: Syncing filesystems ... ");
 626	sys_sync();
 627	printk("done.\n");
 628
 629	error = freeze_processes();
 630	if (error)
 631		goto Free_bitmaps;
 632
 633	error = hibernation_snapshot(hibernation_mode == HIBERNATION_PLATFORM);
 634	if (error || freezer_test_done)
 635		goto Thaw;
 636
 637	if (in_suspend) {
 638		unsigned int flags = 0;
 639
 640		if (hibernation_mode == HIBERNATION_PLATFORM)
 641			flags |= SF_PLATFORM_MODE;
 642		if (nocompress)
 643			flags |= SF_NOCOMPRESS_MODE;
 644		else
 645		        flags |= SF_CRC32_MODE;
 646
 647		pr_debug("PM: writing image.\n");
 
 
 
 
 
 
 
 
 
 
 
 
 
 648		error = swsusp_write(flags);
 649		swsusp_free();
 650		if (!error)
 651			power_down();
 
 
 
 
 652		in_suspend = 0;
 653		pm_restore_gfp_mask();
 654	} else {
 655		pr_debug("PM: Image restored successfully.\n");
 656	}
 657
 
 
 658 Thaw:
 
 
 
 
 
 
 
 659	thaw_processes();
 660
 661	/* Don't bother checking whether freezer_test_done is true */
 662	freezer_test_done = false;
 663
 664 Free_bitmaps:
 665	free_basic_memory_bitmaps();
 666 Exit:
 667	pm_notifier_call_chain(PM_POST_HIBERNATION);
 
 668	pm_restore_console();
 669	atomic_inc(&snapshot_device_available);
 670 Unlock:
 671	unlock_system_sleep();
 
 
 672	return error;
 673}
 674
 675
 676/**
 677 * software_resume - Resume from a saved hibernation image.
 
 
 678 *
 679 * This routine is called as a late initcall, when all devices have been
 680 * discovered and initialized already.
 681 *
 682 * The image reading code is called to see if there is a hibernation image
 683 * available for reading.  If that is the case, devices are quiesced and the
 684 * contents of memory is restored from the saved image.
 685 *
 686 * If this is successful, control reappears in the restored target kernel in
 687 * hibernation_snaphot() which returns to hibernate().  Otherwise, the routine
 688 * attempts to recover gracefully and make the kernel return to the normal mode
 689 * of operation.
 690 */
 691static int software_resume(void)
 692{
 
 693	int error;
 694	unsigned int flags;
 695
 696	/*
 697	 * If the user said "noresume".. bail out early.
 698	 */
 699	if (noresume)
 700		return 0;
 701
 702	/*
 703	 * name_to_dev_t() below takes a sysfs buffer mutex when sysfs
 704	 * is configured into the kernel. Since the regular hibernate
 705	 * trigger path is via sysfs which takes a buffer mutex before
 706	 * calling hibernate functions (which take pm_mutex) this can
 707	 * cause lockdep to complain about a possible ABBA deadlock
 708	 * which cannot happen since we're in the boot code here and
 709	 * sysfs can't be invoked yet. Therefore, we use a subclass
 710	 * here to avoid lockdep complaining.
 711	 */
 712	mutex_lock_nested(&pm_mutex, SINGLE_DEPTH_NESTING);
 713
 714	if (swsusp_resume_device)
 715		goto Check_image;
 716
 717	if (!strlen(resume_file)) {
 718		error = -ENOENT;
 719		goto Unlock;
 720	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 721
 722	pr_debug("PM: Checking hibernation image partition %s\n", resume_file);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 723
 724	if (resume_delay) {
 725		printk(KERN_INFO "Waiting %dsec before reading resume device...\n",
 726			resume_delay);
 727		ssleep(resume_delay);
 728	}
 729
 730	/* Check if the device is there */
 731	swsusp_resume_device = name_to_dev_t(resume_file);
 
 732
 733	/*
 734	 * name_to_dev_t is ineffective to verify parition if resume_file is in
 735	 * integer format. (e.g. major:minor)
 736	 */
 737	if (isdigit(resume_file[0]) && resume_wait) {
 738		int partno;
 739		while (!get_gendisk(swsusp_resume_device, &partno))
 740			msleep(10);
 
 741	}
 742
 743	if (!swsusp_resume_device) {
 744		/*
 745		 * Some device discovery might still be in progress; we need
 746		 * to wait for this to finish.
 747		 */
 748		wait_for_device_probe();
 749
 750		if (resume_wait) {
 751			while ((swsusp_resume_device = name_to_dev_t(resume_file)) == 0)
 752				msleep(10);
 753			async_synchronize_full();
 754		}
 755
 756		swsusp_resume_device = name_to_dev_t(resume_file);
 757		if (!swsusp_resume_device) {
 758			error = -ENODEV;
 759			goto Unlock;
 760		}
 761	}
 762
 763 Check_image:
 764	pr_debug("PM: Hibernation image partition %d:%d present\n",
 765		MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
 766
 767	pr_debug("PM: Looking for hibernation image.\n");
 768	error = swsusp_check();
 
 
 769	if (error)
 770		goto Unlock;
 771
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 772	/* The snapshot device should not be opened while we're running */
 773	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
 774		error = -EBUSY;
 775		swsusp_close(FMODE_READ);
 776		goto Unlock;
 777	}
 778
 
 779	pm_prepare_console();
 780	error = pm_notifier_call_chain(PM_RESTORE_PREPARE);
 781	if (error)
 782		goto close_finish;
 783
 784	error = create_basic_memory_bitmaps();
 
 785	if (error)
 786		goto close_finish;
 787
 788	pr_debug("PM: Preparing processes for restore.\n");
 789	error = freeze_processes();
 790	if (error) {
 791		swsusp_close(FMODE_READ);
 792		goto Done;
 793	}
 794
 795	pr_debug("PM: Loading hibernation image.\n");
 796
 797	error = swsusp_read(&flags);
 798	swsusp_close(FMODE_READ);
 799	if (!error)
 800		hibernation_restore(flags & SF_PLATFORM_MODE);
 801
 802	printk(KERN_ERR "PM: Failed to load hibernation image, recovering.\n");
 803	swsusp_free();
 804	thaw_processes();
 805 Done:
 806	free_basic_memory_bitmaps();
 807 Finish:
 808	pm_notifier_call_chain(PM_POST_RESTORE);
 
 809	pm_restore_console();
 810	atomic_inc(&snapshot_device_available);
 
 811	/* For success case, the suspend path will release the lock */
 812 Unlock:
 813	mutex_unlock(&pm_mutex);
 814	pr_debug("PM: Hibernation image not present or could not be loaded.\n");
 815	return error;
 816close_finish:
 817	swsusp_close(FMODE_READ);
 818	goto Finish;
 819}
 820
 821late_initcall(software_resume);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 822
 823
 824static const char * const hibernation_modes[] = {
 825	[HIBERNATION_PLATFORM]	= "platform",
 826	[HIBERNATION_SHUTDOWN]	= "shutdown",
 827	[HIBERNATION_REBOOT]	= "reboot",
 
 
 
 
 828};
 829
 830/*
 831 * /sys/power/disk - Control hibernation mode.
 832 *
 833 * Hibernation can be handled in several ways.  There are a few different ways
 834 * to put the system into the sleep state: using the platform driver (e.g. ACPI
 835 * or other hibernation_ops), powering it off or rebooting it (for testing
 836 * mostly).
 837 *
 838 * The sysfs file /sys/power/disk provides an interface for selecting the
 839 * hibernation mode to use.  Reading from this file causes the available modes
 840 * to be printed.  There are 3 modes that can be supported:
 841 *
 842 *	'platform'
 843 *	'shutdown'
 844 *	'reboot'
 845 *
 846 * If a platform hibernation driver is in use, 'platform' will be supported
 847 * and will be used by default.  Otherwise, 'shutdown' will be used by default.
 848 * The selected option (i.e. the one corresponding to the current value of
 849 * hibernation_mode) is enclosed by a square bracket.
 850 *
 851 * To select a given hibernation mode it is necessary to write the mode's
 852 * string representation (as returned by reading from /sys/power/disk) back
 853 * into /sys/power/disk.
 854 */
 855
 856static ssize_t disk_show(struct kobject *kobj, struct kobj_attribute *attr,
 857			 char *buf)
 858{
 
 859	int i;
 860	char *start = buf;
 
 
 861
 862	for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
 863		if (!hibernation_modes[i])
 864			continue;
 865		switch (i) {
 866		case HIBERNATION_SHUTDOWN:
 867		case HIBERNATION_REBOOT:
 
 
 
 
 868			break;
 869		case HIBERNATION_PLATFORM:
 870			if (hibernation_ops)
 871				break;
 872			/* not a valid mode, continue with loop */
 873			continue;
 874		}
 875		if (i == hibernation_mode)
 876			buf += sprintf(buf, "[%s] ", hibernation_modes[i]);
 877		else
 878			buf += sprintf(buf, "%s ", hibernation_modes[i]);
 879	}
 880	buf += sprintf(buf, "\n");
 881	return buf-start;
 
 
 
 
 882}
 883
 884static ssize_t disk_store(struct kobject *kobj, struct kobj_attribute *attr,
 885			  const char *buf, size_t n)
 886{
 
 
 887	int error = 0;
 888	int i;
 889	int len;
 890	char *p;
 891	int mode = HIBERNATION_INVALID;
 
 
 
 892
 893	p = memchr(buf, '\n', n);
 894	len = p ? p - buf : n;
 895
 896	lock_system_sleep();
 897	for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
 898		if (len == strlen(hibernation_modes[i])
 899		    && !strncmp(buf, hibernation_modes[i], len)) {
 900			mode = i;
 901			break;
 902		}
 903	}
 904	if (mode != HIBERNATION_INVALID) {
 905		switch (mode) {
 906		case HIBERNATION_SHUTDOWN:
 907		case HIBERNATION_REBOOT:
 
 
 
 
 908			hibernation_mode = mode;
 909			break;
 910		case HIBERNATION_PLATFORM:
 911			if (hibernation_ops)
 912				hibernation_mode = mode;
 913			else
 914				error = -EINVAL;
 915		}
 916	} else
 917		error = -EINVAL;
 918
 919	if (!error)
 920		pr_debug("PM: Hibernation mode set to '%s'\n",
 921			 hibernation_modes[mode]);
 922	unlock_system_sleep();
 923	return error ? error : n;
 924}
 925
 926power_attr(disk);
 927
 928static ssize_t resume_show(struct kobject *kobj, struct kobj_attribute *attr,
 929			   char *buf)
 930{
 931	return sprintf(buf,"%d:%d\n", MAJOR(swsusp_resume_device),
 932		       MINOR(swsusp_resume_device));
 933}
 934
 935static ssize_t resume_store(struct kobject *kobj, struct kobj_attribute *attr,
 936			    const char *buf, size_t n)
 937{
 938	unsigned int maj, min;
 939	dev_t res;
 940	int ret = -EINVAL;
 941
 942	if (sscanf(buf, "%u:%u", &maj, &min) != 2)
 943		goto out;
 944
 945	res = MKDEV(maj,min);
 946	if (maj != MAJOR(res) || min != MINOR(res))
 947		goto out;
 948
 949	lock_system_sleep();
 950	swsusp_resume_device = res;
 951	unlock_system_sleep();
 952	printk(KERN_INFO "PM: Starting manual resume from disk\n");
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 953	noresume = 0;
 954	software_resume();
 955	ret = n;
 956 out:
 957	return ret;
 958}
 959
 960power_attr(resume);
 961
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 962static ssize_t image_size_show(struct kobject *kobj, struct kobj_attribute *attr,
 963			       char *buf)
 964{
 965	return sprintf(buf, "%lu\n", image_size);
 966}
 967
 968static ssize_t image_size_store(struct kobject *kobj, struct kobj_attribute *attr,
 969				const char *buf, size_t n)
 970{
 971	unsigned long size;
 972
 973	if (sscanf(buf, "%lu", &size) == 1) {
 974		image_size = size;
 975		return n;
 976	}
 977
 978	return -EINVAL;
 979}
 980
 981power_attr(image_size);
 982
 983static ssize_t reserved_size_show(struct kobject *kobj,
 984				  struct kobj_attribute *attr, char *buf)
 985{
 986	return sprintf(buf, "%lu\n", reserved_size);
 987}
 988
 989static ssize_t reserved_size_store(struct kobject *kobj,
 990				   struct kobj_attribute *attr,
 991				   const char *buf, size_t n)
 992{
 993	unsigned long size;
 994
 995	if (sscanf(buf, "%lu", &size) == 1) {
 996		reserved_size = size;
 997		return n;
 998	}
 999
1000	return -EINVAL;
1001}
1002
1003power_attr(reserved_size);
1004
1005static struct attribute * g[] = {
1006	&disk_attr.attr,
 
1007	&resume_attr.attr,
1008	&image_size_attr.attr,
1009	&reserved_size_attr.attr,
1010	NULL,
1011};
1012
1013
1014static struct attribute_group attr_group = {
1015	.attrs = g,
1016};
1017
1018
1019static int __init pm_disk_init(void)
1020{
1021	return sysfs_create_group(power_kobj, &attr_group);
1022}
1023
1024core_initcall(pm_disk_init);
1025
1026
1027static int __init resume_setup(char *str)
1028{
1029	if (noresume)
1030		return 1;
1031
1032	strncpy( resume_file, str, 255 );
1033	return 1;
1034}
1035
1036static int __init resume_offset_setup(char *str)
1037{
1038	unsigned long long offset;
1039
1040	if (noresume)
1041		return 1;
1042
1043	if (sscanf(str, "%llu", &offset) == 1)
1044		swsusp_resume_block = offset;
1045
1046	return 1;
1047}
1048
1049static int __init hibernate_setup(char *str)
1050{
1051	if (!strncmp(str, "noresume", 8))
1052		noresume = 1;
1053	else if (!strncmp(str, "nocompress", 10))
1054		nocompress = 1;
 
 
 
 
 
 
 
1055	return 1;
1056}
1057
1058static int __init noresume_setup(char *str)
1059{
1060	noresume = 1;
1061	return 1;
1062}
1063
1064static int __init resumewait_setup(char *str)
1065{
1066	resume_wait = 1;
1067	return 1;
1068}
1069
1070static int __init resumedelay_setup(char *str)
1071{
1072	resume_delay = simple_strtoul(str, NULL, 0);
 
 
 
 
 
 
 
 
 
 
1073	return 1;
1074}
1075
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1076__setup("noresume", noresume_setup);
1077__setup("resume_offset=", resume_offset_setup);
1078__setup("resume=", resume_setup);
1079__setup("hibernate=", hibernate_setup);
1080__setup("resumewait", resumewait_setup);
1081__setup("resumedelay=", resumedelay_setup);