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

/** * resume_target_kernel - Restore system state from a hibernation image. * @platform_mode: Whether or not to use the platform driver. * * Execute device drivers' "noirq" and "late" freeze callbacks, restore the * contents of highmem that have not been restored yet from the image and run * the low-level code that will restore the remaining contents of memory and * switch to the just restored target kernel. */static int resume_target_kernel(bool platform_mode){	int error;	error = dpm_suspend_end(PMSG_QUIESCE);	if (error) {		printk(KERN_ERR "PM: Some devices failed to power down, "			"aborting resume/n");		return error;	}	error = platform_pre_restore(platform_mode);	if (error)		goto Cleanup;	error = disable_nonboot_cpus();	if (error)		goto Enable_cpus;	clockevents_notify(CLOCK_EVT_NOTIFY_SUSPEND, NULL);	local_irq_disable();	error = syscore_suspend();	if (error)		goto Enable_irqs;	save_processor_state();	error = restore_highmem();	if (!error) {		error = swsusp_arch_resume();		/*		 * The code below is only ever reached in case of a failure.		 * Otherwise, execution continues at the place where		 * swsusp_arch_suspend() was called.		 */		BUG_ON(!error);		/*		 * This call to restore_highmem() reverts the changes made by		 * the previous one.		 */		restore_highmem();	}	/*	 * The only reason why swsusp_arch_resume() can fail is memory being	 * very tight, so we have to free it as soon as we can to avoid	 * subsequent failures.	 */	swsusp_free();	restore_processor_state();	touch_softlockup_watchdog();	syscore_resume(); Enable_irqs:	clockevents_notify(CLOCK_EVT_NOTIFY_RESUME, NULL);	local_irq_enable(); Enable_cpus:	enable_nonboot_cpus(); Cleanup:	platform_restore_cleanup(platform_mode);	dpm_resume_start(PMSG_RECOVER);	return error;}

static long snapshot_ioctl(struct file *filp, unsigned int cmd,							unsigned long arg){	int error = 0;	struct snapshot_data *data;	loff_t size;	sector_t offset;	if (_IOC_TYPE(cmd) != SNAPSHOT_IOC_MAGIC)		return -ENOTTY;	if (_IOC_NR(cmd) > SNAPSHOT_IOC_MAXNR)		return -ENOTTY;	if (!capable(CAP_SYS_ADMIN))		return -EPERM;	if (!mutex_trylock(&pm_mutex))		return -EBUSY;	data = filp->private_data;	switch (cmd) {	case SNAPSHOT_FREEZE:		if (data->frozen)			break;		printk("Syncing filesystems ... ");		sys_sync();		printk("done./n");		error = freeze_processes();		if (error)			thaw_processes();		if (!error)			data->frozen = 1;		break;	case SNAPSHOT_UNFREEZE:		if (!data->frozen || data->ready)			break;		thaw_processes();		data->frozen = 0;		break;	case SNAPSHOT_CREATE_IMAGE:	case SNAPSHOT_ATOMIC_SNAPSHOT:		if (data->mode != O_RDONLY || !data->frozen  || data->ready) {			error = -EPERM;			break;		}		error = hibernation_snapshot(data->platform_support);		if (!error)			error = put_user(in_suspend, (int __user *)arg);		if (!error)			data->ready = 1;		break;	case SNAPSHOT_ATOMIC_RESTORE:		snapshot_write_finalize(&data->handle);		if (data->mode != O_WRONLY || !data->frozen ||		    !snapshot_image_loaded(&data->handle)) {			error = -EPERM;			break;		}		error = hibernation_restore(data->platform_support);		break;	case SNAPSHOT_FREE:		swsusp_free();		memset(&data->handle, 0, sizeof(struct snapshot_handle));		data->ready = 0;		break;	case SNAPSHOT_PREF_IMAGE_SIZE:	case SNAPSHOT_SET_IMAGE_SIZE:		image_size = arg;		break;	case SNAPSHOT_GET_IMAGE_SIZE:		if (!data->ready) {			error = -ENODATA;			break;		}		size = snapshot_get_image_size();		size <<= PAGE_SHIFT;		error = put_user(size, (loff_t __user *)arg);		break;	case SNAPSHOT_AVAIL_SWAP_SIZE:	case SNAPSHOT_AVAIL_SWAP:		size = count_swap_pages(data->swap, 1);		size <<= PAGE_SHIFT;		error = put_user(size, (loff_t __user *)arg);		break;	case SNAPSHOT_ALLOC_SWAP_PAGE:	case SNAPSHOT_GET_SWAP_PAGE:		if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {			error = -ENODEV;			break;		}//.........这里部分代码省略.........

/** * hibernation_snapshot - Quiesce devices and create a hibernation image. * @platform_mode: If set, use platform driver to prepare for the transition. * * This routine must be called with pm_mutex held. */int hibernation_snapshot(int platform_mode){	pm_message_t msg;	int error;	error = platform_begin(platform_mode);	if (error)		goto Close;	/* Preallocate image memory before shutting down devices. */	error = hibernate_preallocate_memory();	if (error)		goto Close;	error = freeze_kernel_threads();	if (error)		goto Cleanup;	if (hibernation_test(TEST_FREEZER)) {		/*		 * Indicate to the caller that we are returning due to a		 * successful freezer test.		 */		freezer_test_done = true;		goto Thaw;	}	error = dpm_prepare(PMSG_FREEZE);	if (error) {		dpm_complete(PMSG_RECOVER);		goto Thaw;	}	suspend_console();	pm_restrict_gfp_mask();	error = dpm_suspend(PMSG_FREEZE);	if (error || hibernation_test(TEST_DEVICES))		platform_recover(platform_mode);	else		error = create_image(platform_mode);	/*	 * In the case that we call create_image() above, the control	 * returns here (1) after the image has been created or the	 * image creation has failed and (2) after a successful restore.	 */	/* We may need to release the preallocated image pages here. */	if (error || !in_suspend)		swsusp_free();	msg = in_suspend ? (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE;	dpm_resume(msg);	if (error || !in_suspend)		pm_restore_gfp_mask();	resume_console();	dpm_complete(msg); Close:	platform_end(platform_mode);	return error; Thaw:	thaw_kernel_threads(); Cleanup:	swsusp_free();	goto Close;}

int hibernate(void){	int error;	mutex_lock(&pm_mutex);	/* The snapshot device should not be opened while we're running */	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {		error = -EBUSY;		goto Unlock;	}	pm_prepare_console();	error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);	if (error)		goto Exit;	error = usermodehelper_disable();	if (error)		goto Exit;	/* Allocate memory management structures */	error = create_basic_memory_bitmaps();	if (error)		goto Exit;	printk(KERN_INFO "PM: Syncing filesystems ... ");	sys_sync();	printk("done./n");	error = prepare_processes();	if (error)		goto Finish;	if (hibernation_test(TEST_FREEZER))		goto Thaw;	if (hibernation_testmode(HIBERNATION_TESTPROC))		goto Thaw;	error = hibernation_snapshot(hibernation_mode == HIBERNATION_PLATFORM);	if (in_suspend && !error) {		unsigned int flags = 0;		if (hibernation_mode == HIBERNATION_PLATFORM)			flags |= SF_PLATFORM_MODE;		pr_debug("PM: writing image./n");		error = swsusp_write(flags);		swsusp_free();		if (!error)			power_down();	} else {		pr_debug("PM: Image restored successfully./n");		swsusp_free();	} Thaw:	thaw_processes(); Finish:	free_basic_memory_bitmaps();	usermodehelper_enable(); Exit:	pm_notifier_call_chain(PM_POST_HIBERNATION);	pm_restore_console();	atomic_inc(&snapshot_device_available); Unlock:	mutex_unlock(&pm_mutex);	return error;}

static int software_resume(void){	int error;	unsigned int flags;	/*	 * If the user said "noresume".. bail out early.	 */	if (noresume)		return 0;	/*	 * name_to_dev_t() below takes a sysfs buffer mutex when sysfs	 * is configured into the kernel. Since the regular hibernate	 * trigger path is via sysfs which takes a buffer mutex before	 * calling hibernate functions (which take pm_mutex) this can	 * cause lockdep to complain about a possible ABBA deadlock	 * which cannot happen since we're in the boot code here and	 * sysfs can't be invoked yet. Therefore, we use a subclass	 * here to avoid lockdep complaining.	 */	mutex_lock_nested(&pm_mutex, SINGLE_DEPTH_NESTING);	if (swsusp_resume_device)		goto Check_image;	if (!strlen(resume_file)) {		error = -ENOENT;		goto Unlock;	}	pr_debug("PM: Checking image partition %s/n", resume_file);	/* Check if the device is there */	swsusp_resume_device = name_to_dev_t(resume_file);	if (!swsusp_resume_device) {		/*		 * Some device discovery might still be in progress; we need		 * to wait for this to finish.		 */		wait_for_device_probe();		/*		 * We can't depend on SCSI devices being available after loading		 * one of their modules until scsi_complete_async_scans() is		 * called and the resume device usually is a SCSI one.		 */		scsi_complete_async_scans();		swsusp_resume_device = name_to_dev_t(resume_file);		if (!swsusp_resume_device) {			error = -ENODEV;			goto Unlock;		}	} Check_image:	pr_debug("PM: Resume from partition %d:%d/n",		MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));	pr_debug("PM: Checking hibernation image./n");	error = swsusp_check();	if (error)		goto Unlock;	/* The snapshot device should not be opened while we're running */	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {		error = -EBUSY;		goto Unlock;	}	pm_prepare_console();	error = pm_notifier_call_chain(PM_RESTORE_PREPARE);	if (error)		goto Finish;	error = usermodehelper_disable();	if (error)		goto Finish;	error = create_basic_memory_bitmaps();	if (error)		goto Finish;	pr_debug("PM: Preparing processes for restore./n");	error = prepare_processes();	if (error) {		swsusp_close(FMODE_READ);		goto Done;	}	pr_debug("PM: Reading hibernation image./n");	error = swsusp_read(&flags);	if (!error)		hibernation_restore(flags & SF_PLATFORM_MODE);	printk(KERN_ERR "PM: Restore failed, recovering./n");	swsusp_free();	thaw_processes(); Done://.........这里部分代码省略.........

/** * hibernation_snapshot - Quiesce devices and create a hibernation image. * @platform_mode: If set, use platform driver to prepare for the transition. * * This routine must be called with pm_mutex held. */int hibernation_snapshot(int platform_mode){	pm_message_t msg = PMSG_RECOVER;	int error;	error = platform_begin(platform_mode);	if (error)		goto Close;	/* Preallocate image memory before shutting down devices. */	error = hibernate_preallocate_memory();	if (error)		goto Close;	error = freeze_kernel_threads();	if (error)		goto Close;	error = dpm_prepare(PMSG_FREEZE);	if (error)		goto Complete_devices;	suspend_console();	pm_restrict_gfp_mask();	error = dpm_suspend(PMSG_FREEZE);	if (error)		goto Recover_platform;	if (hibernation_test(TEST_DEVICES))		goto Recover_platform;	error = create_image(platform_mode);	/*	 * Control returns here (1) after the image has been created or the	 * image creation has failed and (2) after a successful restore.	 */ Resume_devices:	/* We may need to release the preallocated image pages here. */	if (error || !in_suspend)		swsusp_free();	msg = in_suspend ? (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE;	dpm_resume(msg);	if (error || !in_suspend)		pm_restore_gfp_mask();	resume_console(); Complete_devices:	dpm_complete(msg); Close:	platform_end(platform_mode);	return error; Recover_platform:	platform_recover(platform_mode);	goto Resume_devices;}

static int resume_target_kernel(bool platform_mode){	int error;	error = dpm_suspend_noirq(PMSG_QUIESCE);	if (error) {		printk(KERN_ERR "PM: Some devices failed to power down, "			"aborting resume/n");		return error;	}	error = platform_pre_restore(platform_mode);	if (error)		goto Cleanup;	error = disable_nonboot_cpus();	if (error)		goto Enable_cpus;	local_irq_disable();	error = sysdev_suspend(PMSG_QUIESCE);	if (error)		goto Enable_irqs;	/* We'll ignore saved state, but this gets preempt count (etc) right */	save_processor_state();	error = restore_highmem();	if (!error) {		error = swsusp_arch_resume();		/*		 * The code below is only ever reached in case of a failure.		 * Otherwise execution continues at place where		 * swsusp_arch_suspend() was called		 */		BUG_ON(!error);		/* This call to restore_highmem() undos the previous one */		restore_highmem();	}	/*	 * The only reason why swsusp_arch_resume() can fail is memory being	 * very tight, so we have to free it as soon as we can to avoid	 * subsequent failures	 */	swsusp_free();	restore_processor_state();	touch_softlockup_watchdog();	sysdev_resume(); Enable_irqs:	local_irq_enable(); Enable_cpus:	enable_nonboot_cpus(); Cleanup:	platform_restore_cleanup(platform_mode);	dpm_resume_noirq(PMSG_RECOVER);	return error;}

/** * hibernate - Carry out system hibernation, including saving the image. */int hibernate(void){	int error, nr_calls = 0;	bool snapshot_test = false;	if (!hibernation_available()) {		pm_pr_dbg("Hibernation not available./n");		return -EPERM;	}	lock_system_sleep();	/* The snapshot device should not be opened while we're running */	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {		error = -EBUSY;		goto Unlock;	}	pr_info("hibernation entry/n");	pm_prepare_console();	error = __pm_notifier_call_chain(PM_HIBERNATION_PREPARE, -1, &nr_calls);	if (error) {		nr_calls--;		goto Exit;	}	pr_info("Syncing filesystems ... /n");	ksys_sync();	pr_info("done./n");	error = freeze_processes();	if (error)		goto Exit;	lock_device_hotplug();	/* Allocate memory management structures */	error = create_basic_memory_bitmaps();	if (error)		goto Thaw;	error = hibernation_snapshot(hibernation_mode == HIBERNATION_PLATFORM);	if (error || freezer_test_done)		goto Free_bitmaps;	if (in_suspend) {		unsigned int flags = 0;		if (hibernation_mode == HIBERNATION_PLATFORM)			flags |= SF_PLATFORM_MODE;		if (nocompress)			flags |= SF_NOCOMPRESS_MODE;		else		        flags |= SF_CRC32_MODE;		pm_pr_dbg("Writing image./n");		error = swsusp_write(flags);		swsusp_free();		if (!error) {			if (hibernation_mode == HIBERNATION_TEST_RESUME)				snapshot_test = true;			else				power_down();		}		in_suspend = 0;		pm_restore_gfp_mask();	} else {		pm_pr_dbg("Image restored successfully./n");	} Free_bitmaps:	free_basic_memory_bitmaps(); Thaw:	unlock_device_hotplug();	if (snapshot_test) {		pm_pr_dbg("Checking hibernation image/n");		error = swsusp_check();		if (!error)			error = load_image_and_restore();	}	thaw_processes();	/* Don't bother checking whether freezer_test_done is true */	freezer_test_done = false; Exit:	__pm_notifier_call_chain(PM_POST_HIBERNATION, nr_calls, NULL);	pm_restore_console();	atomic_inc(&snapshot_device_available); Unlock:	unlock_system_sleep();	pr_info("hibernation exit/n");	return error;}

int pm_suspend_disk(void){	int error;	error = prepare_processes();	if (error)		return error;	if (pm_disk_mode == PM_DISK_TESTPROC) {		printk("swsusp debug: Waiting for 5 seconds./n");		mdelay(5000);		goto Thaw;	}	/* Allocate memory management structures */	error = create_basic_memory_bitmaps();	if (error)		goto Thaw;	/* Free memory before shutting down devices. */	error = swsusp_shrink_memory();	if (error)		goto Finish;	error = platform_prepare();	if (error)		goto Finish;	suspend_console();	error = device_suspend(PMSG_FREEZE);	if (error) {		printk(KERN_ERR "PM: Some devices failed to suspend/n");		goto Resume_devices;	}	error = disable_nonboot_cpus();	if (error)		goto Enable_cpus;	if (pm_disk_mode == PM_DISK_TEST) {		printk("swsusp debug: Waiting for 5 seconds./n");		mdelay(5000);		goto Enable_cpus;	}	pr_debug("PM: snapshotting memory./n");	in_suspend = 1;	error = swsusp_suspend();	if (error)		goto Enable_cpus;	if (in_suspend) {		enable_nonboot_cpus();		platform_finish();		device_resume();		resume_console();		pr_debug("PM: writing image./n");		error = swsusp_write();		if (!error)			power_down(pm_disk_mode);		else {			swsusp_free();			goto Finish;		}	} else {		pr_debug("PM: Image restored successfully./n");	}	swsusp_free(); Enable_cpus:	enable_nonboot_cpus(); Resume_devices:	platform_finish();	device_resume();	resume_console(); Finish:	free_basic_memory_bitmaps(); Thaw:	unprepare_processes();	return error;}

static int software_resume(void){	int error;	mutex_lock(&pm_mutex);	if (!swsusp_resume_device) {		if (!strlen(resume_file)) {			mutex_unlock(&pm_mutex);			return -ENOENT;		}		swsusp_resume_device = name_to_dev_t(resume_file);		pr_debug("swsusp: Resume From Partition %s/n", resume_file);	} else {		pr_debug("swsusp: Resume From Partition %d:%d/n",			 MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));	}	if (noresume) {		/**		 * FIXME: If noresume is specified, we need to find the partition		 * and reset it back to normal swap space.		 */		mutex_unlock(&pm_mutex);		return 0;	}	pr_debug("PM: Checking swsusp image./n");	error = swsusp_check();	if (error)		goto Unlock;	error = create_basic_memory_bitmaps();	if (error)		goto Unlock;	pr_debug("PM: Preparing processes for restore./n");	error = prepare_processes();	if (error) {		swsusp_close();		goto Done;	}	pr_debug("PM: Reading swsusp image./n");	error = swsusp_read();	if (error) {		swsusp_free();		goto Thaw;	}	pr_debug("PM: Preparing devices for restore./n");	suspend_console();	error = device_suspend(PMSG_PRETHAW);	if (error)		goto Free;	error = disable_nonboot_cpus();	if (!error)		swsusp_resume();	enable_nonboot_cpus(); Free:	swsusp_free();	device_resume();	resume_console(); Thaw:	printk(KERN_ERR "PM: Restore failed, recovering./n");	unprepare_processes(); Done:	free_basic_memory_bitmaps();	/* For success case, the suspend path will release the lock */ Unlock:	mutex_unlock(&pm_mutex);	pr_debug("PM: Resume from disk failed./n");	return 0;}

static long snapshot_ioctl(struct file *filp, unsigned int cmd,							unsigned long arg){	int error = 0;	struct snapshot_data *data;	loff_t size;	sector_t offset;	if (_IOC_TYPE(cmd) != SNAPSHOT_IOC_MAGIC)		return -ENOTTY;	if (_IOC_NR(cmd) > SNAPSHOT_IOC_MAXNR)		return -ENOTTY;	if (!capable(CAP_SYS_ADMIN))		return -EPERM;	if (!mutex_trylock(&pm_mutex))		return -EBUSY;	data = filp->private_data;	switch (cmd) {	case SNAPSHOT_FREEZE:		if (data->frozen)			break;		printk("Syncing filesystems ... ");		sys_sync();		printk("done./n");		error = usermodehelper_disable();		if (error)			break;		error = freeze_processes();		if (error)			usermodehelper_enable();		else			data->frozen = 1;		break;	case SNAPSHOT_UNFREEZE:		if (!data->frozen || data->ready)			break;		pm_restore_gfp_mask();		thaw_processes();		usermodehelper_enable();		data->frozen = 0;		break;	case SNAPSHOT_CREATE_IMAGE:		if (data->mode != O_RDONLY || !data->frozen  || data->ready) {			error = -EPERM;			break;		}		pm_restore_gfp_mask();		error = hibernation_snapshot(data->platform_support);		if (!error) {			error = put_user(in_suspend, (int __user *)arg);			if (!error && !freezer_test_done)				data->ready = 1;			if (freezer_test_done) {				freezer_test_done = false;				thaw_processes();			}		}		break;	case SNAPSHOT_ATOMIC_RESTORE:		snapshot_write_finalize(&data->handle);		if (data->mode != O_WRONLY || !data->frozen ||		    !snapshot_image_loaded(&data->handle)) {			error = -EPERM;			break;		}		error = hibernation_restore(data->platform_support);		break;	case SNAPSHOT_FREE:		swsusp_free();		memset(&data->handle, 0, sizeof(struct snapshot_handle));		data->ready = 0;		/*		 * It is necessary to thaw kernel threads here, because		 * SNAPSHOT_CREATE_IMAGE may be invoked directly after		 * SNAPSHOT_FREE.  In that case, if kernel threads were not		 * thawed, the preallocation of memory carried out by		 * hibernation_snapshot() might run into problems (i.e. it		 * might fail or even deadlock).		 */		thaw_kernel_threads();		break;	case SNAPSHOT_PREF_IMAGE_SIZE:		image_size = arg;		break;	case SNAPSHOT_GET_IMAGE_SIZE:		if (!data->ready) {			error = -ENODATA;//.........这里部分代码省略.........

static int snapshot_ioctl(struct inode *inode, struct file *filp,                          unsigned int cmd, unsigned long arg){    int error = 0;    struct snapshot_data *data;    loff_t offset, avail;    if (_IOC_TYPE(cmd) != SNAPSHOT_IOC_MAGIC)        return -ENOTTY;    if (_IOC_NR(cmd) > SNAPSHOT_IOC_MAXNR)        return -ENOTTY;    if (!capable(CAP_SYS_ADMIN))        return -EPERM;    data = filp->private_data;    switch (cmd) {    case SNAPSHOT_FREEZE:        if (data->frozen)            break;        down(&pm_sem);        disable_nonboot_cpus();        if (freeze_processes()) {            thaw_processes();            enable_nonboot_cpus();            error = -EBUSY;        }        up(&pm_sem);        if (!error)            data->frozen = 1;        break;    case SNAPSHOT_UNFREEZE:        if (!data->frozen)            break;        down(&pm_sem);        thaw_processes();        enable_nonboot_cpus();        up(&pm_sem);        data->frozen = 0;        break;    case SNAPSHOT_ATOMIC_SNAPSHOT:        if (data->mode != O_RDONLY || !data->frozen  || data->ready) {            error = -EPERM;            break;        }        down(&pm_sem);        /* Free memory before shutting down devices. */        error = swsusp_shrink_memory();        if (!error) {            error = device_suspend(PMSG_FREEZE);            if (!error) {                in_suspend = 1;                error = swsusp_suspend();                device_resume();            }        }        up(&pm_sem);        if (!error)            error = put_user(in_suspend, (unsigned int __user *)arg);        if (!error)            data->ready = 1;        break;    case SNAPSHOT_ATOMIC_RESTORE:        if (data->mode != O_WRONLY || !data->frozen ||                !snapshot_image_loaded(&data->handle)) {            error = -EPERM;            break;        }        down(&pm_sem);        pm_prepare_console();        error = device_suspend(PMSG_FREEZE);        if (!error) {            error = swsusp_resume();            device_resume();        }        pm_restore_console();        up(&pm_sem);        break;    case SNAPSHOT_FREE:        swsusp_free();        memset(&data->handle, 0, sizeof(struct snapshot_handle));        data->ready = 0;        break;    case SNAPSHOT_SET_IMAGE_SIZE:        image_size = arg;        break;    case SNAPSHOT_AVAIL_SWAP:        avail = count_swap_pages(data->swap, 1);        avail <<= PAGE_SHIFT;        error = put_user(avail, (loff_t __user *)arg);        break;    case SNAPSHOT_GET_SWAP_PAGE://.........这里部分代码省略.........

static long snapshot_ioctl(struct file *filp, unsigned int cmd,							unsigned long arg){	int error = 0;	struct snapshot_data *data;	loff_t size;	sector_t offset;	if (_IOC_TYPE(cmd) != SNAPSHOT_IOC_MAGIC)		return -ENOTTY;	if (_IOC_NR(cmd) > SNAPSHOT_IOC_MAXNR)		return -ENOTTY;	if (!capable(CAP_SYS_ADMIN))		return -EPERM;	if (!mutex_trylock(&pm_mutex))		return -EBUSY;	data = filp->private_data;	switch (cmd) {	case SNAPSHOT_FREEZE:		if (data->frozen)			break;		printk("Syncing filesystems ... ");		sys_sync();		printk("done./n");		error = freeze_processes();		if (!error)			data->frozen = 1;		break;	case SNAPSHOT_UNFREEZE:		if (!data->frozen || data->ready)			break;		pm_restore_gfp_mask();		thaw_processes();		data->frozen = 0;		break;	case SNAPSHOT_CREATE_IMAGE:		if (data->mode != O_RDONLY || !data->frozen  || data->ready) {			error = -EPERM;			break;		}		pm_restore_gfp_mask();		error = hibernation_snapshot(data->platform_support);		if (!error) {			error = put_user(in_suspend, (int __user *)arg);			data->ready = !freezer_test_done && !error;			freezer_test_done = false;		}		break;	case SNAPSHOT_ATOMIC_RESTORE:		snapshot_write_finalize(&data->handle);		if (data->mode != O_WRONLY || !data->frozen ||		    !snapshot_image_loaded(&data->handle)) {			error = -EPERM;			break;		}		error = hibernation_restore(data->platform_support);		break;	case SNAPSHOT_FREE:		swsusp_free();		memset(&data->handle, 0, sizeof(struct snapshot_handle));		data->ready = 0;		thaw_kernel_threads();		break;	case SNAPSHOT_PREF_IMAGE_SIZE:		image_size = arg;		break;	case SNAPSHOT_GET_IMAGE_SIZE:		if (!data->ready) {			error = -ENODATA;			break;		}		size = snapshot_get_image_size();		size <<= PAGE_SHIFT;		error = put_user(size, (loff_t __user *)arg);		break;	case SNAPSHOT_AVAIL_SWAP_SIZE:		size = count_swap_pages(data->swap, 1);		size <<= PAGE_SHIFT;		error = put_user(size, (loff_t __user *)arg);		break;	case SNAPSHOT_ALLOC_SWAP_PAGE:		if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {			error = -ENODEV;			break;		}		offset = alloc_swapdev_block(data->swap);//.........这里部分代码省略.........

/** * hibernate - Carry out system hibernation, including saving the image. */int hibernate(void){	int error;	if (!hibernation_available()) {		pr_debug("PM: Hibernation not available./n");		return -EPERM;	}	lock_system_sleep();	/* The snapshot device should not be opened while we're running */	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {		error = -EBUSY;		goto Unlock;	}	pm_prepare_console();	error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);	if (error)		goto Exit;	printk(KERN_INFO "PM: Syncing filesystems ... ");	sys_sync();	printk("done./n");	error = freeze_processes();	if (error)		goto Exit;	lock_device_hotplug();	/* Allocate memory management structures */	error = create_basic_memory_bitmaps();	if (error)		goto Thaw;	error = hibernation_snapshot(hibernation_mode == HIBERNATION_PLATFORM);	if (error || freezer_test_done)		goto Free_bitmaps;	if (in_suspend) {		unsigned int flags = 0;		if (hibernation_mode == HIBERNATION_PLATFORM)			flags |= SF_PLATFORM_MODE;		if (nocompress)			flags |= SF_NOCOMPRESS_MODE;		else		        flags |= SF_CRC32_MODE;		pr_debug("PM: writing image./n");		error = swsusp_write(flags);		swsusp_free();		if (!error)			power_down();		in_suspend = 0;		pm_restore_gfp_mask();	} else {		pr_debug("PM: Image restored successfully./n");	} Free_bitmaps:	free_basic_memory_bitmaps(); Thaw:	unlock_device_hotplug();	thaw_processes();	/* Don't bother checking whether freezer_test_done is true */	freezer_test_done = false; Exit:	pm_notifier_call_chain(PM_POST_HIBERNATION);	pm_restore_console();	atomic_inc(&snapshot_device_available); Unlock:	unlock_system_sleep();	return error;}

static int software_resume(void){	int error;	unsigned int flags;	/*	 * name_to_dev_t() below takes a sysfs buffer mutex when sysfs	 * is configured into the kernel. Since the regular hibernate	 * trigger path is via sysfs which takes a buffer mutex before	 * calling hibernate functions (which take pm_mutex) this can	 * cause lockdep to complain about a possible ABBA deadlock	 * which cannot happen since we're in the boot code here and	 * sysfs can't be invoked yet. Therefore, we use a subclass	 * here to avoid lockdep complaining.	 */	mutex_lock_nested(&pm_mutex, SINGLE_DEPTH_NESTING);	if (!swsusp_resume_device) {		if (!strlen(resume_file)) {			mutex_unlock(&pm_mutex);			return -ENOENT;		}		swsusp_resume_device = name_to_dev_t(resume_file);		pr_debug("PM: Resume from partition %s/n", resume_file);	} else {		pr_debug("PM: Resume from partition %d:%d/n",				MAJOR(swsusp_resume_device),				MINOR(swsusp_resume_device));	}	if (noresume) {		/**		 * FIXME: If noresume is specified, we need to find the		 * partition and reset it back to normal swap space.		 */		mutex_unlock(&pm_mutex);		return 0;	}	pr_debug("PM: Checking hibernation image./n");	error = swsusp_check();	if (error)		goto Unlock;	/* The snapshot device should not be opened while we're running */	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {		error = -EBUSY;		goto Unlock;	}	pm_prepare_console();	error = pm_notifier_call_chain(PM_RESTORE_PREPARE);	if (error)		goto Finish;	error = create_basic_memory_bitmaps();	if (error)		goto Finish;	pr_debug("PM: Preparing processes for restore./n");	error = prepare_processes();	if (error) {		swsusp_close();		goto Done;	}	pr_debug("PM: Reading hibernation image./n");	error = swsusp_read(&flags);	if (!error)		hibernation_restore(flags & SF_PLATFORM_MODE);	printk(KERN_ERR "PM: Restore failed, recovering./n");	swsusp_free();	thaw_processes(); Done:	free_basic_memory_bitmaps(); Finish:	pm_notifier_call_chain(PM_POST_RESTORE);	pm_restore_console();	atomic_inc(&snapshot_device_available);	/* For success case, the suspend path will release the lock */ Unlock:	mutex_unlock(&pm_mutex);	pr_debug("PM: Resume from disk failed./n");	return error;}

//.........这里部分代码省略.........	}	pr_debug("PM: Checking hibernation image partition %s/n", resume_file);	if (resume_delay) {		printk(KERN_INFO "Waiting %dsec before reading resume device.../n",			resume_delay);		ssleep(resume_delay);	}	/* Check if the device is there */	swsusp_resume_device = name_to_dev_t(resume_file);	/*	 * name_to_dev_t is ineffective to verify parition if resume_file is in	 * integer format. (e.g. major:minor)	 */	if (isdigit(resume_file[0]) && resume_wait) {		int partno;		while (!get_gendisk(swsusp_resume_device, &partno))			msleep(10);	}	if (!swsusp_resume_device) {		/*		 * Some device discovery might still be in progress; we need		 * to wait for this to finish.		 */		wait_for_device_probe();		if (resume_wait) {			while ((swsusp_resume_device = name_to_dev_t(resume_file)) == 0)				msleep(10);			async_synchronize_full();		}		swsusp_resume_device = name_to_dev_t(resume_file);		if (!swsusp_resume_device) {			error = -ENODEV;			goto Unlock;		}	} Check_image:	pr_debug("PM: Hibernation image partition %d:%d present/n",		MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));	pr_debug("PM: Looking for hibernation image./n");	error = swsusp_check();	if (error)		goto Unlock;	/* The snapshot device should not be opened while we're running */	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {		error = -EBUSY;		swsusp_close(FMODE_READ);		goto Unlock;	}	pm_prepare_console();	error = pm_notifier_call_chain(PM_RESTORE_PREPARE);	if (error)		goto Close_Finish;	pr_debug("PM: Preparing processes for restore./n");	error = freeze_processes();	if (error)		goto Close_Finish;	pr_debug("PM: Loading hibernation image./n");	lock_device_hotplug();	error = create_basic_memory_bitmaps();	if (error)		goto Thaw;	error = swsusp_read(&flags);	swsusp_close(FMODE_READ);	if (!error)		hibernation_restore(flags & SF_PLATFORM_MODE);	printk(KERN_ERR "PM: Failed to load hibernation image, recovering./n");	swsusp_free();	free_basic_memory_bitmaps(); Thaw:	unlock_device_hotplug();	thaw_processes(); Finish:	pm_notifier_call_chain(PM_POST_RESTORE);	pm_restore_console();	atomic_inc(&snapshot_device_available);	/* For success case, the suspend path will release the lock */ Unlock:	mutex_unlock(&pm_mutex);	pr_debug("PM: Hibernation image not present or could not be loaded./n");	return error; Close_Finish:	swsusp_close(FMODE_READ);	goto Finish;}