自学教程：C++ suspend_console函数代码示例

/** * hibernation_restore - Quiesce devices and restore from a hibernation image. * @platform_mode: If set, use platform driver to prepare for the transition. * * This routine must be called with pm_mutex held.  If it is successful, control * reappears in the restored target kernel in hibernation_snapshot(). */int hibernation_restore(int platform_mode){	int error;	pm_prepare_console();	suspend_console();	ftrace_stop();	pm_restrict_gfp_mask();	error = dpm_suspend_start(PMSG_QUIESCE);	if (!error) {		error = resume_target_kernel(platform_mode);		/*		 * The above should either succeed and jump to the new kernel,		 * or return with an error. Otherwise things are just		 * undefined, so let's be paranoid.		 */		BUG_ON(!error);	}	dpm_resume_end(PMSG_RECOVER);	pm_restore_gfp_mask();	ftrace_start();	resume_console();	pm_restore_console();	return error;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (!suspend_ops)		return -ENOSYS;	trace_machine_suspend(state);	if (suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	}	suspend_console();	suspend_test_start();	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to suspend/n");		goto Recover_platform;	}	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup		&& suspend_ops->suspend_again && suspend_ops->suspend_again()); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);#ifdef CONFIG_MACH_LGE_325_BOARD_VZW#ifdef CONFIG_LGE_LOG_SERVICE    if(sleep_enter == 1){	    struct timespec ts;	    struct rtc_time tm;	    getnstimeofday(&ts);	    rtc_time_to_tm(ts.tv_sec, &tm);	    printk(KERN_UTC_WAKEUP "%d-%02d-%02d %02d:%02d:%02d.%06lu/n",	                    tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,	                    tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec/1000);	    sleep_enter = 0;	}#endif#endif	suspend_test_finish("resume devices");	resume_console(); Close:	if (suspend_ops->end)		suspend_ops->end();	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

static inline int snapshot_restore(int platform_suspend){	int error;	mutex_lock(&pm_mutex);	pm_prepare_console();	if (platform_suspend) {		error = platform_prepare();		if (error)			goto Finish;	}	suspend_console();	error = device_suspend(PMSG_PRETHAW);	if (error)		goto Resume_devices;	error = disable_nonboot_cpus();	if (!error)		error = swsusp_resume();	enable_nonboot_cpus(); Resume_devices:	if (platform_suspend)		platform_finish();	device_resume();	resume_console(); Finish:	pm_restore_console();	mutex_unlock(&pm_mutex);	return error;}

static bool s3c_cm_suspend_again(void){	bool ret;	int i = 0;	if (!is_charger_manager_active())		return false;	while (s3c_cm_devices && s3c_cm_devices[i]) {		pm_generic_resume(s3c_cm_devices[i]);		i++;	}	if (s3c_cm_resume_console)		resume_console();	ret = cm_suspend_again();	if (s3c_cm_resume_console)		suspend_console();	while (i > 0) {		i--;		pm_generic_suspend(s3c_cm_devices[i]);	}	return ret;}

/** *	suspend_devices_and_enter - suspend devices and enter the desired system sleep *			  state. *	@state:		  state to enter */int suspend_devices_and_enter(suspend_state_t state){	int error;	if (!pm_ops)		return -ENOSYS;	if (pm_ops->set_target) {		error = pm_ops->set_target(state);		if (error)			return error;	}	suspend_console();	error = device_suspend(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "Some devices failed to suspend/n");		goto Resume_console;	}	if (pm_ops->prepare) {		error = pm_ops->prepare(state);		if (error)			goto Resume_devices;	}	error = disable_nonboot_cpus();	if (!error)		suspend_enter(state);	enable_nonboot_cpus();	pm_finish(state); Resume_devices:	device_resume(); Resume_console:	resume_console();	return error;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (!suspend_ops)		return -ENOSYS;	trace_machine_suspend(state);	if (suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	}	suspend_console();	ftrace_stop();	suspend_test_start();	/* time stamp for start of device suspend */	time_stamp_in_suspend_flow(DEV_SUS, true);	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to suspend/n");		goto Recover_platform;	}	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup		&& suspend_ops->suspend_again && suspend_ops->suspend_again());	if (wakeup)		error = -EBUSY; Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);	/* time stamp for end of device resume */	time_stamp_in_suspend_flow(DEV_RES, false);	suspend_test_finish("resume devices");	ftrace_start();	resume_console(); Close:	if (suspend_ops->end)		suspend_ops->end();	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

/** *	suspend_devices_and_enter - suspend devices and enter the desired system *				    sleep state. *	@state:		  state to enter */int suspend_devices_and_enter(suspend_state_t state){	int error, ftrace_save;	if (!suspend_ops)		return -ENOSYS;	if (suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	}	suspend_console();	ftrace_save = __ftrace_enabled_save();	suspend_test_start();	error = device_suspend(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to suspend/n");		goto Recover_platform;	}	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	if (suspend_ops->prepare) {		error = suspend_ops->prepare();		if (error)			goto Resume_devices;	}	if (suspend_test(TEST_PLATFORM))		goto Finish;	error = disable_nonboot_cpus();	if (!error && !suspend_test(TEST_CPUS))		suspend_enter(state);	enable_nonboot_cpus(); Finish:	if (suspend_ops->finish)		suspend_ops->finish(); Resume_devices:	suspend_test_start();	device_resume(PMSG_RESUME);	suspend_test_finish("resume devices");	__ftrace_enabled_restore(ftrace_save);	resume_console(); Close:	if (suspend_ops->end)		suspend_ops->end();	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

int hibernation_platform_enter(void){	int error;	if (!hibernation_ops)		return -ENOSYS;	/*	 * We have cancelled the power transition by running	 * hibernation_ops->finish() before saving the image, so we should let	 * the firmware know that we're going to enter the sleep state after all	 */	error = hibernation_ops->begin();	if (error)		goto Close;	suspend_console();	error = device_suspend(PMSG_HIBERNATE);	if (error) {		if (hibernation_ops->recover)			hibernation_ops->recover();		goto Resume_devices;	}	error = hibernation_ops->prepare();	if (error)		goto Resume_devices;	error = disable_nonboot_cpus();	if (error)		goto Finish;	device_pm_lock();	local_irq_disable();	error = device_power_down(PMSG_HIBERNATE);	if (!error) {		hibernation_ops->enter();		/* We should never get here */		while (1);	}	local_irq_enable();	device_pm_unlock();	/*	 * We don't need to reenable the nonboot CPUs or resume consoles, since	 * the system is going to be halted anyway.	 */ Finish:	hibernation_ops->finish(); Resume_devices:	device_resume(PMSG_RESTORE);	resume_console(); Close:	hibernation_ops->end();	return error;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (need_suspend_ops(state) && !suspend_ops)		return -ENOSYS;	trace_machine_suspend(state);	if (need_suspend_ops(state) && suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	} else if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->begin) {		error = freeze_ops->begin();		if (error)			goto Close;	}	suspend_console();	ftrace_stop();	suspend_test_start();	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to suspend/n");		log_suspend_abort_reason("Some devices failed to suspend");		goto Recover_platform;	}	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup && need_suspend_ops(state)		&& platform_suspend_again()); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);	suspend_test_finish("resume devices");	ftrace_start();	resume_console(); Close:	if (need_suspend_ops(state) && suspend_ops->end)		suspend_ops->end();	else if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->end)		freeze_ops->end();	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (need_suspend_ops(state) && suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){    int error;    bool wakeup = false;    if (!suspend_ops)        return -ENOSYS;    trace_machine_suspend(state);    if (suspend_ops->begin) {        error = suspend_ops->begin(state);        if (error)            goto Close;    }    suspend_console();    suspend_test_start();    error = dpm_suspend_start(PMSG_SUSPEND);    /*OPPO 2012-11-27 zhzhyon Add for reason*/#ifdef CONFIG_VENDOR_EDIT    if(has_wake_lock(WAKE_LOCK_SUSPEND))    {        goto Resume_devices;    }#endif    /*OPPO 2012-11-27 zhzhyon Add end*/    if (error) {        printk(KERN_ERR "PM: Some devices failed to suspend/n");        goto Recover_platform;    }    suspend_test_finish("suspend devices");    if (suspend_test(TEST_DEVICES))        goto Recover_platform;    do {        error = suspend_enter(state, &wakeup);    } while (!error && !wakeup             && suspend_ops->suspend_again && suspend_ops->suspend_again());Resume_devices:    suspend_test_start();    dpm_resume_end(PMSG_RESUME);    suspend_test_finish("resume devices");    resume_console();Close:    if (suspend_ops->end)        suspend_ops->end();    trace_machine_suspend(PWR_EVENT_EXIT);    return error;Recover_platform:    if (suspend_ops->recover)        suspend_ops->recover();    goto Resume_devices;}

int pm_suspend_disk(void){	int error;	error = prepare_processes();	if (error)		return error;	if (pm_disk_mode == PM_DISK_TESTPROC)		return 0;	suspend_console();	error = device_suspend(PMSG_FREEZE);	if (error) {		resume_console();		printk("Some devices failed to suspend/n");		goto Thaw;	}	if (pm_disk_mode == PM_DISK_TEST) {		printk("swsusp debug: Waiting for 5 seconds./n");		mdelay(5000);		goto Done;	}	pr_debug("PM: snapshotting memory./n");	in_suspend = 1;	if ((error = swsusp_suspend()))		goto Done;	if (in_suspend) {		device_resume();		resume_console();		pr_debug("PM: writing image./n");		error = swsusp_write();		if (!error)			power_down(pm_disk_mode);		else {			swsusp_free();			goto Thaw;		}	} else {		pr_debug("PM: Image restored successfully./n");	}	swsusp_free(); Done:	device_resume();	resume_console(); Thaw:	unprepare_processes();	return error;}

int hibernation_snapshot(int platform_mode){	int error;	/* Free memory before shutting down devices. */	error = swsusp_shrink_memory();	if (error)		return error;	error = platform_begin(platform_mode);	if (error)		goto Close;	suspend_console();	error = device_suspend(PMSG_FREEZE);	if (error)		goto Recover_platform;	if (hibernation_test(TEST_DEVICES))		goto Recover_platform;	error = platform_pre_snapshot(platform_mode);	if (error || hibernation_test(TEST_PLATFORM))		goto Finish;	error = disable_nonboot_cpus();	if (!error) {		if (hibernation_test(TEST_CPUS))			goto Enable_cpus;		if (hibernation_testmode(HIBERNATION_TEST))			goto Enable_cpus;		error = create_image(platform_mode);		/* Control returns here after successful restore */	} Enable_cpus:	enable_nonboot_cpus(); Finish:	platform_finish(platform_mode); Resume_devices:	device_resume(in_suspend ?		(error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);	resume_console(); Close:	platform_end(platform_mode);	return error; Recover_platform:	platform_recover(platform_mode);	goto Resume_devices;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (need_suspend_ops(state) && !suspend_ops)		return -ENOSYS;#ifdef CONFIG_TOI	drop_pagecache();#endif 	trace_machine_suspend(state);	if (need_suspend_ops(state) && suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	}	suspend_console();	ftrace_stop();	suspend_test_start();	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to suspend/n");		goto Recover_platform;	}	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup && need_suspend_ops(state)		&& suspend_ops->suspend_again && suspend_ops->suspend_again()); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);	suspend_test_finish("resume devices");	ftrace_start();	resume_console(); Close:	if (need_suspend_ops(state) && suspend_ops->end)		suspend_ops->end();	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (need_suspend_ops(state) && suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (need_suspend_ops(state) && !suspend_ops)		return -ENOSYS;	if (need_suspend_ops(state) && suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	} else if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->begin) {		error = freeze_ops->begin();		if (error)			goto Close;	}	suspend_console();	suspend_test_start();	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		pr_err("PM: Some devices failed to suspend, or early wake event detected/n");		goto Recover_platform;	}	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup && need_suspend_ops(state)		&& suspend_ops->suspend_again && suspend_ops->suspend_again()); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);	suspend_test_finish("resume devices");	resume_console(); Close:	if (need_suspend_ops(state) && suspend_ops->end)		suspend_ops->end();	else if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->end)		freeze_ops->end();	return error; Recover_platform:	if (need_suspend_ops(state) && suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

static int suspend_prepare(suspend_state_t state){	int error;	unsigned int free_pages;	if (!pm_ops || !pm_ops->enter)		return -EPERM;	pm_prepare_console();	if (freeze_processes()) {		error = -EAGAIN;		goto Thaw;	}	if ((free_pages = global_page_state(NR_FREE_PAGES))			< FREE_PAGE_NUMBER) {		pr_debug("PM: free some memory/n");		shrink_all_memory(FREE_PAGE_NUMBER - free_pages);		if (nr_free_pages() < FREE_PAGE_NUMBER) {			error = -ENOMEM;			printk(KERN_ERR "PM: No enough memory/n");			goto Thaw;		}	}	if (pm_ops->prepare) {		if ((error = pm_ops->prepare(state)))			goto Thaw;	}	suspend_console();	error = device_suspend(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "Some devices failed to suspend/n");		goto Resume_devices;	}	error = disable_nonboot_cpus();	if (!error)		return 0;	enable_nonboot_cpus(); Resume_devices:	pm_finish(state);	device_resume();	resume_console(); Thaw:	thaw_processes();	pm_restore_console();	return error;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (!suspend_ops)		return -ENOSYS;	trace_machine_suspend(state);	if (suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	}	suspend_console();	suspend_test_start();	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to suspend/n");		goto Recover_platform;	}	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup		&& suspend_ops->suspend_again && suspend_ops->suspend_again()); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);#ifdef CONFIG_ZTE_PLATFORM_RECORD_APP_AWAKE_SUSPEND_TIME	pr_info("Resume DONE /n");	//LHX_PM_20110113 add log to indicate resume finish	record_sleep_awake_time(false);		//LHX_PM_20110324_01 add code to record how long the APP sleeps or keeps awake #endif	suspend_test_finish("resume devices");	resume_console(); Close:	if (suspend_ops->end)		suspend_ops->end();	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

int hibernation_restore(int platform_mode){	int error;	pm_prepare_console();	suspend_console();	error = dpm_suspend_start(PMSG_QUIESCE);	if (!error) {		error = resume_target_kernel(platform_mode);		dpm_resume_end(PMSG_RECOVER);	}	resume_console();	pm_restore_console();	return error;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (!sleep_state_supported(state))		return -ENOSYS;	pm_suspend_target_state = state;	error = platform_suspend_begin(state);	if (error)		goto Close;	suspend_console();	suspend_test_start();	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		pr_err("Some devices failed to suspend, or early wake event detected/n");		goto Recover_platform;	}	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup && platform_suspend_again(state)); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);	suspend_test_finish("resume devices");	trace_suspend_resume(TPS("resume_console"), state, true);	resume_console();	trace_suspend_resume(TPS("resume_console"), state, false); Close:	platform_resume_end(state);	pm_suspend_target_state = PM_SUSPEND_ON;	return error; Recover_platform:	platform_recover(state);	goto Resume_devices;}

/** *	suspend_devices_and_enter - suspend devices and enter the desired system *				    sleep state. *	@state:		  state to enter */int suspend_devices_and_enter(suspend_state_t state){	int error;	if (!suspend_ops)		return -ENOSYS;	trace_machine_suspend(state);	if (suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	}	suspend_console();	suspend_test_start();	suspend_expire_start();	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to suspend/n");		goto Recover_platform;	}	suspend_expire_finish("suspend devices");	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	suspend_enter(state); Resume_devices:	suspend_test_start();	suspend_expire_start();	dpm_resume_end(PMSG_RESUME);	suspend_expire_finish("resume devices");	suspend_test_finish("resume devices");	resume_console(); Close:	if (suspend_ops->end)		suspend_ops->end();	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

/** *	suspend_devices_and_enter - suspend devices and enter the desired system *				    sleep state. *	@state:		  state to enter */int suspend_devices_and_enter(suspend_state_t state){	int error;	if (!suspend_ops)		return -ENOSYS;	if (suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	}	suspend_console();	pm_restrict_gfp_mask();	suspend_test_start();	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to suspend/n");		goto Recover_platform;	}	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	suspend_enter(state); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);	ktime_resume_endtime=ktime_get();	printk(KERN_ERR "<POWER>resume6[peripheral resume]take %llu ns/n",ktime_to_ns(ktime_sub(ktime_resume_endtime, ktime_resume_fromtime)));	ktime_resume_fromtime=ktime_resume_endtime;	suspend_test_finish("resume devices");	pm_restore_gfp_mask();	resume_console(); Close:	if (suspend_ops->end)		suspend_ops->end();	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

void pre_suspend(void){#ifdef CONFIG_NETFRONT    suspend_netfront();#endif    suspend_xenbus();    local_irq_disable();    suspend_gnttab();    suspend_time();    suspend_console();    suspend_events();}

int hibernation_restore(int platform_mode){	int error;	gfp_t saved_mask;	pm_prepare_console();	suspend_console();	saved_mask = clear_gfp_allowed_mask(GFP_IOFS);	error = dpm_suspend_start(PMSG_QUIESCE);	if (!error) {		error = resume_target_kernel(platform_mode);		dpm_resume_end(PMSG_RECOVER);	}	set_gfp_allowed_mask(saved_mask);	resume_console();	pm_restore_console();	return error;}

int hibernation_snapshot(int platform_mode){	int error;	gfp_t saved_mask;	error = platform_begin(platform_mode);	if (error)		return error;	/* Preallocate image memory before shutting down devices. */	error = hibernate_preallocate_memory();	if (error)		goto Close;	suspend_console();	saved_mask = clear_gfp_allowed_mask(GFP_IOFS);	error = dpm_suspend_start(PMSG_FREEZE);	if (error)		goto Recover_platform;	if (hibernation_test(TEST_DEVICES))		goto Recover_platform;	error = create_image(platform_mode);	/* Control returns here after successful restore */ Resume_devices:	/* We may need to release the preallocated image pages here. */	if (error || !in_suspend)		swsusp_free();	dpm_resume_end(in_suspend ?		(error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);	set_gfp_allowed_mask(saved_mask);	resume_console(); Close:	platform_end(platform_mode);	return error; Recover_platform:	platform_recover(platform_mode);	goto Resume_devices;}

int hibernation_snapshot(int platform_mode){	int error;	/* Free memory before shutting down devices. */	error = swsusp_shrink_memory();	if (error)		return error;	error = platform_start(platform_mode);	if (error)		return error;	suspend_console();	error = device_suspend(PMSG_FREEZE);	if (error)		goto Resume_console;	error = platform_pre_snapshot(platform_mode);	if (error)		goto Resume_devices;	error = disable_nonboot_cpus();	if (!error) {		if (hibernation_mode != HIBERNATION_TEST) {			in_suspend = 1;			error = create_image(platform_mode);			/* Control returns here after successful restore */		} else {			printk("swsusp debug: Waiting for 5 seconds./n");			mdelay(5000);		}	}	enable_nonboot_cpus(); Resume_devices:	platform_finish(platform_mode);	device_resume(); Resume_console:	resume_console();	return error;}

static inline int snapshot_suspend(int platform_suspend){	int error;	mutex_lock(&pm_mutex);	/* Free memory before shutting down devices. */	error = swsusp_shrink_memory();	if (error)		goto Finish;	if (platform_suspend) {		error = platform_prepare();		if (error)			goto Finish;	}	suspend_console();	error = device_suspend(PMSG_FREEZE);	if (error)		goto Resume_devices;	error = disable_nonboot_cpus();	if (!error) {		in_suspend = 1;		error = swsusp_suspend();	}	enable_nonboot_cpus(); Resume_devices:	if (platform_suspend)		platform_finish();	device_resume();	resume_console(); Finish:	mutex_unlock(&pm_mutex);	return error;}

int hibernation_snapshot(int platform_mode){	int error;	error = platform_begin(platform_mode);	if (error)		return error;	/* Free memory before shutting down devices. */	error = swsusp_shrink_memory();	if (error)		goto Close;	suspend_console();	error = dpm_suspend_start(PMSG_FREEZE);	if (error)		goto Recover_platform;	if (hibernation_test(TEST_DEVICES))		goto Recover_platform;	error = create_image(platform_mode);	/* Control returns here after successful restore */ Resume_devices:	dpm_resume_end(in_suspend ?		(error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);	resume_console(); Close:	platform_end(platform_mode);	return error; Recover_platform:	platform_recover(platform_mode);	goto Resume_devices;}