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