2006-03-23 12:00:00 +01:00
|
|
|
/*
|
|
|
|
* linux/kernel/power/swap.c
|
|
|
|
*
|
|
|
|
* This file provides functions for reading the suspend image from
|
|
|
|
* and writing it to a swap partition.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1998,2001-2005 Pavel Machek <pavel@suse.cz>
|
|
|
|
* Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
|
|
|
|
*
|
|
|
|
* This file is released under the GPLv2.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/file.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <linux/genhd.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/bio.h>
|
2006-09-26 08:32:44 +02:00
|
|
|
#include <linux/blkdev.h>
|
2006-03-23 12:00:00 +01:00
|
|
|
#include <linux/swap.h>
|
|
|
|
#include <linux/swapops.h>
|
|
|
|
#include <linux/pm.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2006-03-23 12:00:00 +01:00
|
|
|
|
|
|
|
#include "power.h"
|
|
|
|
|
|
|
|
#define SWSUSP_SIG "S1SUSPEND"
|
|
|
|
|
2007-05-02 19:27:07 +02:00
|
|
|
struct swsusp_header {
|
swsusp: introduce restore platform operations
At least on some machines it is necessary to prepare the ACPI firmware for the
restoration of the system memory state from the hibernation image if the
"platform" mode of hibernation has been used. Namely, in that cases we need
to disable the GPEs before replacing the "boot" kernel with the "frozen"
kernel (cf. http://bugzilla.kernel.org/show_bug.cgi?id=7887). After the
restore they will be re-enabled by hibernation_ops->finish(), but if the
restore fails, they have to be re-enabled by the restore code explicitly.
For this purpose we can introduce two additional hibernation operations,
called pre_restore() and restore_cleanup() and call them from the restore code
path. Still, they should be called if the "platform" mode of hibernation has
been used, so we need to pass the information about the hibernation mode from
the "frozen" kernel to the "boot" kernel in the image header.
Apparently, we can't drop the disabling of GPEs before the restore because of
Bug #7887 . We also can't do it unconditionally, because the GPEs wouldn't
have been enabled after a successful restore if the suspend had been done in
the 'shutdown' or 'reboot' mode.
In principle we could (and probably should) unconditionally disable the GPEs
before each snapshot creation *and* before the restore, but then we'd have to
unconditionally enable them after the snapshot creation as well as after the
restore (or restore failure) Still, for this purpose we'd need to modify
acpi_enter_sleep_state_prep() and acpi_leave_sleep_state() and we'd have to
introduce some mechanism synchronizing the disablind/enabling of the GPEs with
the device drivers' .suspend()/.resume() routines and with
disable_/enable_nonboot_cpus(). However, this would have affected the
suspend (ie. s2ram) code as well as the hibernation, which I'd like to avoid
in this patch series.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Nigel Cunningham <nigel@nigel.suspend2.net>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 10:47:30 +02:00
|
|
|
char reserved[PAGE_SIZE - 20 - sizeof(sector_t) - sizeof(int)];
|
2006-12-07 05:34:10 +01:00
|
|
|
sector_t image;
|
swsusp: introduce restore platform operations
At least on some machines it is necessary to prepare the ACPI firmware for the
restoration of the system memory state from the hibernation image if the
"platform" mode of hibernation has been used. Namely, in that cases we need
to disable the GPEs before replacing the "boot" kernel with the "frozen"
kernel (cf. http://bugzilla.kernel.org/show_bug.cgi?id=7887). After the
restore they will be re-enabled by hibernation_ops->finish(), but if the
restore fails, they have to be re-enabled by the restore code explicitly.
For this purpose we can introduce two additional hibernation operations,
called pre_restore() and restore_cleanup() and call them from the restore code
path. Still, they should be called if the "platform" mode of hibernation has
been used, so we need to pass the information about the hibernation mode from
the "frozen" kernel to the "boot" kernel in the image header.
Apparently, we can't drop the disabling of GPEs before the restore because of
Bug #7887 . We also can't do it unconditionally, because the GPEs wouldn't
have been enabled after a successful restore if the suspend had been done in
the 'shutdown' or 'reboot' mode.
In principle we could (and probably should) unconditionally disable the GPEs
before each snapshot creation *and* before the restore, but then we'd have to
unconditionally enable them after the snapshot creation as well as after the
restore (or restore failure) Still, for this purpose we'd need to modify
acpi_enter_sleep_state_prep() and acpi_leave_sleep_state() and we'd have to
introduce some mechanism synchronizing the disablind/enabling of the GPEs with
the device drivers' .suspend()/.resume() routines and with
disable_/enable_nonboot_cpus(). However, this would have affected the
suspend (ie. s2ram) code as well as the hibernation, which I'd like to avoid
in this patch series.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Nigel Cunningham <nigel@nigel.suspend2.net>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 10:47:30 +02:00
|
|
|
unsigned int flags; /* Flags to pass to the "boot" kernel */
|
2006-03-23 12:00:00 +01:00
|
|
|
char orig_sig[10];
|
|
|
|
char sig[10];
|
2007-05-02 19:27:07 +02:00
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
static struct swsusp_header *swsusp_header;
|
2006-03-23 12:00:00 +01:00
|
|
|
|
2009-12-06 16:15:53 +01:00
|
|
|
/**
|
|
|
|
* The following functions are used for tracing the allocated
|
|
|
|
* swap pages, so that they can be freed in case of an error.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct swsusp_extent {
|
|
|
|
struct rb_node node;
|
|
|
|
unsigned long start;
|
|
|
|
unsigned long end;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct rb_root swsusp_extents = RB_ROOT;
|
|
|
|
|
|
|
|
static int swsusp_extents_insert(unsigned long swap_offset)
|
|
|
|
{
|
|
|
|
struct rb_node **new = &(swsusp_extents.rb_node);
|
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct swsusp_extent *ext;
|
|
|
|
|
|
|
|
/* Figure out where to put the new node */
|
|
|
|
while (*new) {
|
|
|
|
ext = container_of(*new, struct swsusp_extent, node);
|
|
|
|
parent = *new;
|
|
|
|
if (swap_offset < ext->start) {
|
|
|
|
/* Try to merge */
|
|
|
|
if (swap_offset == ext->start - 1) {
|
|
|
|
ext->start--;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
new = &((*new)->rb_left);
|
|
|
|
} else if (swap_offset > ext->end) {
|
|
|
|
/* Try to merge */
|
|
|
|
if (swap_offset == ext->end + 1) {
|
|
|
|
ext->end++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
new = &((*new)->rb_right);
|
|
|
|
} else {
|
|
|
|
/* It already is in the tree */
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Add the new node and rebalance the tree. */
|
|
|
|
ext = kzalloc(sizeof(struct swsusp_extent), GFP_KERNEL);
|
|
|
|
if (!ext)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ext->start = swap_offset;
|
|
|
|
ext->end = swap_offset;
|
|
|
|
rb_link_node(&ext->node, parent, new);
|
|
|
|
rb_insert_color(&ext->node, &swsusp_extents);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* alloc_swapdev_block - allocate a swap page and register that it has
|
|
|
|
* been allocated, so that it can be freed in case of an error.
|
|
|
|
*/
|
|
|
|
|
|
|
|
sector_t alloc_swapdev_block(int swap)
|
|
|
|
{
|
|
|
|
unsigned long offset;
|
|
|
|
|
|
|
|
offset = swp_offset(get_swap_page_of_type(swap));
|
|
|
|
if (offset) {
|
|
|
|
if (swsusp_extents_insert(offset))
|
|
|
|
swap_free(swp_entry(swap, offset));
|
|
|
|
else
|
|
|
|
return swapdev_block(swap, offset);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* free_all_swap_pages - free swap pages allocated for saving image data.
|
|
|
|
* It also frees the extents used to register which swap entres had been
|
|
|
|
* allocated.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void free_all_swap_pages(int swap)
|
|
|
|
{
|
|
|
|
struct rb_node *node;
|
|
|
|
|
|
|
|
while ((node = swsusp_extents.rb_node)) {
|
|
|
|
struct swsusp_extent *ext;
|
|
|
|
unsigned long offset;
|
|
|
|
|
|
|
|
ext = container_of(node, struct swsusp_extent, node);
|
|
|
|
rb_erase(node, &swsusp_extents);
|
|
|
|
for (offset = ext->start; offset <= ext->end; offset++)
|
|
|
|
swap_free(swp_entry(swap, offset));
|
|
|
|
|
|
|
|
kfree(ext);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int swsusp_swap_in_use(void)
|
|
|
|
{
|
|
|
|
return (swsusp_extents.rb_node != NULL);
|
|
|
|
}
|
|
|
|
|
2006-03-23 12:00:00 +01:00
|
|
|
/*
|
2006-12-07 05:34:09 +01:00
|
|
|
* General things
|
2006-03-23 12:00:00 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned short root_swap = 0xffff;
|
2006-12-07 05:34:09 +01:00
|
|
|
static struct block_device *resume_bdev;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* submit - submit BIO request.
|
|
|
|
* @rw: READ or WRITE.
|
|
|
|
* @off physical offset of page.
|
|
|
|
* @page: page we're reading or writing.
|
|
|
|
* @bio_chain: list of pending biod (for async reading)
|
|
|
|
*
|
|
|
|
* Straight from the textbook - allocate and initialize the bio.
|
|
|
|
* If we're reading, make sure the page is marked as dirty.
|
|
|
|
* Then submit it and, if @bio_chain == NULL, wait.
|
|
|
|
*/
|
|
|
|
static int submit(int rw, pgoff_t page_off, struct page *page,
|
|
|
|
struct bio **bio_chain)
|
|
|
|
{
|
2009-02-16 10:25:40 +01:00
|
|
|
const int bio_rw = rw | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG);
|
2006-12-07 05:34:09 +01:00
|
|
|
struct bio *bio;
|
|
|
|
|
2006-12-07 05:34:19 +01:00
|
|
|
bio = bio_alloc(__GFP_WAIT | __GFP_HIGH, 1);
|
2006-12-07 05:34:09 +01:00
|
|
|
bio->bi_sector = page_off * (PAGE_SIZE >> 9);
|
|
|
|
bio->bi_bdev = resume_bdev;
|
|
|
|
bio->bi_end_io = end_swap_bio_read;
|
|
|
|
|
|
|
|
if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
|
2007-12-08 02:09:43 +01:00
|
|
|
printk(KERN_ERR "PM: Adding page to bio failed at %ld\n",
|
|
|
|
page_off);
|
2006-12-07 05:34:09 +01:00
|
|
|
bio_put(bio);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
lock_page(page);
|
|
|
|
bio_get(bio);
|
|
|
|
|
|
|
|
if (bio_chain == NULL) {
|
2009-02-16 10:25:40 +01:00
|
|
|
submit_bio(bio_rw, bio);
|
2006-12-07 05:34:09 +01:00
|
|
|
wait_on_page_locked(page);
|
|
|
|
if (rw == READ)
|
|
|
|
bio_set_pages_dirty(bio);
|
|
|
|
bio_put(bio);
|
|
|
|
} else {
|
|
|
|
if (rw == READ)
|
|
|
|
get_page(page); /* These pages are freed later */
|
|
|
|
bio->bi_private = *bio_chain;
|
|
|
|
*bio_chain = bio;
|
2009-02-16 10:25:40 +01:00
|
|
|
submit_bio(bio_rw, bio);
|
2006-12-07 05:34:09 +01:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int bio_read_page(pgoff_t page_off, void *addr, struct bio **bio_chain)
|
|
|
|
{
|
|
|
|
return submit(READ, page_off, virt_to_page(addr), bio_chain);
|
|
|
|
}
|
|
|
|
|
2006-12-07 05:34:10 +01:00
|
|
|
static int bio_write_page(pgoff_t page_off, void *addr, struct bio **bio_chain)
|
2006-12-07 05:34:09 +01:00
|
|
|
{
|
2006-12-07 05:34:10 +01:00
|
|
|
return submit(WRITE, page_off, virt_to_page(addr), bio_chain);
|
2006-12-07 05:34:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int wait_on_bio_chain(struct bio **bio_chain)
|
|
|
|
{
|
|
|
|
struct bio *bio;
|
|
|
|
struct bio *next_bio;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (bio_chain == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bio = *bio_chain;
|
|
|
|
if (bio == NULL)
|
|
|
|
return 0;
|
|
|
|
while (bio) {
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
next_bio = bio->bi_private;
|
|
|
|
page = bio->bi_io_vec[0].bv_page;
|
|
|
|
wait_on_page_locked(page);
|
|
|
|
if (!PageUptodate(page) || PageError(page))
|
|
|
|
ret = -EIO;
|
|
|
|
put_page(page);
|
|
|
|
bio_put(bio);
|
|
|
|
bio = next_bio;
|
|
|
|
}
|
|
|
|
*bio_chain = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Saving part
|
|
|
|
*/
|
2006-03-23 12:00:00 +01:00
|
|
|
|
swsusp: introduce restore platform operations
At least on some machines it is necessary to prepare the ACPI firmware for the
restoration of the system memory state from the hibernation image if the
"platform" mode of hibernation has been used. Namely, in that cases we need
to disable the GPEs before replacing the "boot" kernel with the "frozen"
kernel (cf. http://bugzilla.kernel.org/show_bug.cgi?id=7887). After the
restore they will be re-enabled by hibernation_ops->finish(), but if the
restore fails, they have to be re-enabled by the restore code explicitly.
For this purpose we can introduce two additional hibernation operations,
called pre_restore() and restore_cleanup() and call them from the restore code
path. Still, they should be called if the "platform" mode of hibernation has
been used, so we need to pass the information about the hibernation mode from
the "frozen" kernel to the "boot" kernel in the image header.
Apparently, we can't drop the disabling of GPEs before the restore because of
Bug #7887 . We also can't do it unconditionally, because the GPEs wouldn't
have been enabled after a successful restore if the suspend had been done in
the 'shutdown' or 'reboot' mode.
In principle we could (and probably should) unconditionally disable the GPEs
before each snapshot creation *and* before the restore, but then we'd have to
unconditionally enable them after the snapshot creation as well as after the
restore (or restore failure) Still, for this purpose we'd need to modify
acpi_enter_sleep_state_prep() and acpi_leave_sleep_state() and we'd have to
introduce some mechanism synchronizing the disablind/enabling of the GPEs with
the device drivers' .suspend()/.resume() routines and with
disable_/enable_nonboot_cpus(). However, this would have affected the
suspend (ie. s2ram) code as well as the hibernation, which I'd like to avoid
in this patch series.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Nigel Cunningham <nigel@nigel.suspend2.net>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 10:47:30 +02:00
|
|
|
static int mark_swapfiles(sector_t start, unsigned int flags)
|
2006-03-23 12:00:00 +01:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2007-05-02 19:27:07 +02:00
|
|
|
bio_read_page(swsusp_resume_block, swsusp_header, NULL);
|
|
|
|
if (!memcmp("SWAP-SPACE",swsusp_header->sig, 10) ||
|
|
|
|
!memcmp("SWAPSPACE2",swsusp_header->sig, 10)) {
|
|
|
|
memcpy(swsusp_header->orig_sig,swsusp_header->sig, 10);
|
|
|
|
memcpy(swsusp_header->sig,SWSUSP_SIG, 10);
|
|
|
|
swsusp_header->image = start;
|
swsusp: introduce restore platform operations
At least on some machines it is necessary to prepare the ACPI firmware for the
restoration of the system memory state from the hibernation image if the
"platform" mode of hibernation has been used. Namely, in that cases we need
to disable the GPEs before replacing the "boot" kernel with the "frozen"
kernel (cf. http://bugzilla.kernel.org/show_bug.cgi?id=7887). After the
restore they will be re-enabled by hibernation_ops->finish(), but if the
restore fails, they have to be re-enabled by the restore code explicitly.
For this purpose we can introduce two additional hibernation operations,
called pre_restore() and restore_cleanup() and call them from the restore code
path. Still, they should be called if the "platform" mode of hibernation has
been used, so we need to pass the information about the hibernation mode from
the "frozen" kernel to the "boot" kernel in the image header.
Apparently, we can't drop the disabling of GPEs before the restore because of
Bug #7887 . We also can't do it unconditionally, because the GPEs wouldn't
have been enabled after a successful restore if the suspend had been done in
the 'shutdown' or 'reboot' mode.
In principle we could (and probably should) unconditionally disable the GPEs
before each snapshot creation *and* before the restore, but then we'd have to
unconditionally enable them after the snapshot creation as well as after the
restore (or restore failure) Still, for this purpose we'd need to modify
acpi_enter_sleep_state_prep() and acpi_leave_sleep_state() and we'd have to
introduce some mechanism synchronizing the disablind/enabling of the GPEs with
the device drivers' .suspend()/.resume() routines and with
disable_/enable_nonboot_cpus(). However, this would have affected the
suspend (ie. s2ram) code as well as the hibernation, which I'd like to avoid
in this patch series.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Nigel Cunningham <nigel@nigel.suspend2.net>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 10:47:30 +02:00
|
|
|
swsusp_header->flags = flags;
|
2006-12-07 05:34:12 +01:00
|
|
|
error = bio_write_page(swsusp_resume_block,
|
2007-05-02 19:27:07 +02:00
|
|
|
swsusp_header, NULL);
|
2006-03-23 12:00:00 +01:00
|
|
|
} else {
|
2007-12-08 02:09:43 +01:00
|
|
|
printk(KERN_ERR "PM: Swap header not found!\n");
|
2006-03-23 12:00:00 +01:00
|
|
|
error = -ENODEV;
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* swsusp_swap_check - check if the resume device is a swap device
|
|
|
|
* and get its index (if so)
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int swsusp_swap_check(void) /* This is called before saving image */
|
|
|
|
{
|
2006-12-07 05:34:10 +01:00
|
|
|
int res;
|
|
|
|
|
2007-01-06 01:36:28 +01:00
|
|
|
res = swap_type_of(swsusp_resume_device, swsusp_resume_block,
|
|
|
|
&resume_bdev);
|
2006-12-07 05:34:10 +01:00
|
|
|
if (res < 0)
|
|
|
|
return res;
|
|
|
|
|
|
|
|
root_swap = res;
|
2007-10-08 19:24:05 +02:00
|
|
|
res = blkdev_get(resume_bdev, FMODE_WRITE);
|
2007-01-06 01:36:28 +01:00
|
|
|
if (res)
|
|
|
|
return res;
|
2006-12-07 05:34:10 +01:00
|
|
|
|
|
|
|
res = set_blocksize(resume_bdev, PAGE_SIZE);
|
|
|
|
if (res < 0)
|
2008-02-23 02:40:24 +01:00
|
|
|
blkdev_put(resume_bdev, FMODE_WRITE);
|
2006-03-23 12:00:00 +01:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* write_page - Write one page to given swap location.
|
|
|
|
* @buf: Address we're writing.
|
|
|
|
* @offset: Offset of the swap page we're writing to.
|
2006-09-26 08:32:42 +02:00
|
|
|
* @bio_chain: Link the next write BIO here
|
2006-03-23 12:00:00 +01:00
|
|
|
*/
|
|
|
|
|
2006-12-07 05:34:10 +01:00
|
|
|
static int write_page(void *buf, sector_t offset, struct bio **bio_chain)
|
2006-03-23 12:00:00 +01:00
|
|
|
{
|
2006-12-07 05:34:10 +01:00
|
|
|
void *src;
|
|
|
|
|
|
|
|
if (!offset)
|
|
|
|
return -ENOSPC;
|
|
|
|
|
|
|
|
if (bio_chain) {
|
2006-12-07 05:34:19 +01:00
|
|
|
src = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
|
2006-12-07 05:34:10 +01:00
|
|
|
if (src) {
|
|
|
|
memcpy(src, buf, PAGE_SIZE);
|
|
|
|
} else {
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
bio_chain = NULL; /* Go synchronous */
|
|
|
|
src = buf;
|
2006-09-26 08:32:42 +02:00
|
|
|
}
|
2006-12-07 05:34:10 +01:00
|
|
|
} else {
|
|
|
|
src = buf;
|
2006-03-23 12:00:00 +01:00
|
|
|
}
|
2006-12-07 05:34:10 +01:00
|
|
|
return bio_write_page(offset, src, bio_chain);
|
2006-03-23 12:00:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The swap map is a data structure used for keeping track of each page
|
|
|
|
* written to a swap partition. It consists of many swap_map_page
|
|
|
|
* structures that contain each an array of MAP_PAGE_SIZE swap entries.
|
|
|
|
* These structures are stored on the swap and linked together with the
|
|
|
|
* help of the .next_swap member.
|
|
|
|
*
|
|
|
|
* The swap map is created during suspend. The swap map pages are
|
|
|
|
* allocated and populated one at a time, so we only need one memory
|
|
|
|
* page to set up the entire structure.
|
|
|
|
*
|
|
|
|
* During resume we also only need to use one swap_map_page structure
|
|
|
|
* at a time.
|
|
|
|
*/
|
|
|
|
|
2006-12-07 05:34:10 +01:00
|
|
|
#define MAP_PAGE_ENTRIES (PAGE_SIZE / sizeof(sector_t) - 1)
|
2006-03-23 12:00:00 +01:00
|
|
|
|
|
|
|
struct swap_map_page {
|
2006-12-07 05:34:10 +01:00
|
|
|
sector_t entries[MAP_PAGE_ENTRIES];
|
|
|
|
sector_t next_swap;
|
2006-03-23 12:00:00 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The swap_map_handle structure is used for handling swap in
|
|
|
|
* a file-alike way
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct swap_map_handle {
|
|
|
|
struct swap_map_page *cur;
|
2006-12-07 05:34:10 +01:00
|
|
|
sector_t cur_swap;
|
2006-03-23 12:00:00 +01:00
|
|
|
unsigned int k;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void release_swap_writer(struct swap_map_handle *handle)
|
|
|
|
{
|
|
|
|
if (handle->cur)
|
|
|
|
free_page((unsigned long)handle->cur);
|
|
|
|
handle->cur = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_swap_writer(struct swap_map_handle *handle)
|
|
|
|
{
|
|
|
|
handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
|
|
|
|
if (!handle->cur)
|
|
|
|
return -ENOMEM;
|
2007-05-06 23:50:47 +02:00
|
|
|
handle->cur_swap = alloc_swapdev_block(root_swap);
|
2006-03-23 12:00:00 +01:00
|
|
|
if (!handle->cur_swap) {
|
|
|
|
release_swap_writer(handle);
|
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
handle->k = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-26 08:32:42 +02:00
|
|
|
static int swap_write_page(struct swap_map_handle *handle, void *buf,
|
|
|
|
struct bio **bio_chain)
|
|
|
|
{
|
|
|
|
int error = 0;
|
2006-12-07 05:34:10 +01:00
|
|
|
sector_t offset;
|
2006-03-23 12:00:00 +01:00
|
|
|
|
|
|
|
if (!handle->cur)
|
|
|
|
return -EINVAL;
|
2007-05-06 23:50:47 +02:00
|
|
|
offset = alloc_swapdev_block(root_swap);
|
2006-09-26 08:32:42 +02:00
|
|
|
error = write_page(buf, offset, bio_chain);
|
2006-03-23 12:00:00 +01:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
handle->cur->entries[handle->k++] = offset;
|
|
|
|
if (handle->k >= MAP_PAGE_ENTRIES) {
|
2006-09-26 08:32:42 +02:00
|
|
|
error = wait_on_bio_chain(bio_chain);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
2007-05-06 23:50:47 +02:00
|
|
|
offset = alloc_swapdev_block(root_swap);
|
2006-03-23 12:00:00 +01:00
|
|
|
if (!offset)
|
|
|
|
return -ENOSPC;
|
|
|
|
handle->cur->next_swap = offset;
|
2006-09-26 08:32:42 +02:00
|
|
|
error = write_page(handle->cur, handle->cur_swap, NULL);
|
2006-03-23 12:00:00 +01:00
|
|
|
if (error)
|
2006-09-26 08:32:42 +02:00
|
|
|
goto out;
|
2006-03-23 12:00:00 +01:00
|
|
|
memset(handle->cur, 0, PAGE_SIZE);
|
|
|
|
handle->cur_swap = offset;
|
|
|
|
handle->k = 0;
|
|
|
|
}
|
2006-12-07 05:34:44 +01:00
|
|
|
out:
|
2006-09-26 08:32:42 +02:00
|
|
|
return error;
|
2006-03-23 12:00:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int flush_swap_writer(struct swap_map_handle *handle)
|
|
|
|
{
|
|
|
|
if (handle->cur && handle->cur_swap)
|
2006-09-26 08:32:42 +02:00
|
|
|
return write_page(handle->cur, handle->cur_swap, NULL);
|
2006-03-23 12:00:00 +01:00
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* save_image - save the suspend image data
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int save_image(struct swap_map_handle *handle,
|
|
|
|
struct snapshot_handle *snapshot,
|
2006-09-26 08:32:41 +02:00
|
|
|
unsigned int nr_to_write)
|
2006-03-23 12:00:00 +01:00
|
|
|
{
|
|
|
|
unsigned int m;
|
|
|
|
int ret;
|
2006-09-26 08:32:41 +02:00
|
|
|
int nr_pages;
|
2006-09-26 08:32:42 +02:00
|
|
|
int err2;
|
|
|
|
struct bio *bio;
|
2006-09-26 08:32:41 +02:00
|
|
|
struct timeval start;
|
|
|
|
struct timeval stop;
|
2006-03-23 12:00:00 +01:00
|
|
|
|
2007-12-08 02:09:43 +01:00
|
|
|
printk(KERN_INFO "PM: Saving image data pages (%u pages) ... ",
|
|
|
|
nr_to_write);
|
2006-09-26 08:32:41 +02:00
|
|
|
m = nr_to_write / 100;
|
2006-03-23 12:00:00 +01:00
|
|
|
if (!m)
|
|
|
|
m = 1;
|
|
|
|
nr_pages = 0;
|
2006-09-26 08:32:42 +02:00
|
|
|
bio = NULL;
|
2006-09-26 08:32:41 +02:00
|
|
|
do_gettimeofday(&start);
|
2009-10-28 22:55:33 +01:00
|
|
|
while (1) {
|
2010-05-01 23:52:02 +02:00
|
|
|
ret = snapshot_read_next(snapshot);
|
2009-10-28 22:55:33 +01:00
|
|
|
if (ret <= 0)
|
|
|
|
break;
|
|
|
|
ret = swap_write_page(handle, data_of(*snapshot), &bio);
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
if (!(nr_pages % m))
|
2009-12-06 16:16:24 +01:00
|
|
|
printk(KERN_CONT "\b\b\b\b%3d%%", nr_pages / m);
|
2009-10-28 22:55:33 +01:00
|
|
|
nr_pages++;
|
|
|
|
}
|
2006-09-26 08:32:42 +02:00
|
|
|
err2 = wait_on_bio_chain(&bio);
|
2006-09-26 08:32:41 +02:00
|
|
|
do_gettimeofday(&stop);
|
2009-10-28 22:55:33 +01:00
|
|
|
if (!ret)
|
|
|
|
ret = err2;
|
|
|
|
if (!ret)
|
2009-12-06 16:16:24 +01:00
|
|
|
printk(KERN_CONT "\b\b\b\bdone\n");
|
2009-10-28 22:55:33 +01:00
|
|
|
else
|
2009-12-06 16:16:24 +01:00
|
|
|
printk(KERN_CONT "\n");
|
2006-12-07 05:34:32 +01:00
|
|
|
swsusp_show_speed(&start, &stop, nr_to_write, "Wrote");
|
2009-10-28 22:55:33 +01:00
|
|
|
return ret;
|
2006-03-23 12:00:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* enough_swap - Make sure we have enough swap to save the image.
|
|
|
|
*
|
|
|
|
* Returns TRUE or FALSE after checking the total amount of swap
|
|
|
|
* space avaiable from the resume partition.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int enough_swap(unsigned int nr_pages)
|
|
|
|
{
|
|
|
|
unsigned int free_swap = count_swap_pages(root_swap, 1);
|
|
|
|
|
2007-12-08 02:09:43 +01:00
|
|
|
pr_debug("PM: Free swap pages: %u\n", free_swap);
|
[PATCH] swsusp: Use memory bitmaps during resume
Make swsusp use memory bitmaps to store its internal information during the
resume phase of the suspend-resume cycle.
If the pfns of saveable pages are saved during the suspend phase instead of
the kernel virtual addresses of these pages, we can use them during the resume
phase directly to set the corresponding bits in a memory bitmap. Then, this
bitmap is used to mark the page frames corresponding to the pages that were
saveable before the suspend (aka "unsafe" page frames).
Next, we allocate as many page frames as needed to store the entire suspend
image and make sure that there will be some extra free "safe" page frames for
the list of PBEs constructed later. Subsequently, the image is loaded and, if
possible, the data loaded from it are written into their "original" page
frames (ie. the ones they had occupied before the suspend).
The image data that cannot be written into their "original" page frames are
loaded into "safe" page frames and their "original" kernel virtual addresses,
as well as the addresses of the "safe" pages containing their copies, are
stored in a list of PBEs. Finally, the list of PBEs is used to copy the
remaining image data into their "original" page frames (this is done
atomically, by the architecture-dependent parts of swsusp).
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Acked-by: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-26 08:32:55 +02:00
|
|
|
return free_swap > nr_pages + PAGES_FOR_IO;
|
2006-03-23 12:00:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* swsusp_write - Write entire image and metadata.
|
swsusp: introduce restore platform operations
At least on some machines it is necessary to prepare the ACPI firmware for the
restoration of the system memory state from the hibernation image if the
"platform" mode of hibernation has been used. Namely, in that cases we need
to disable the GPEs before replacing the "boot" kernel with the "frozen"
kernel (cf. http://bugzilla.kernel.org/show_bug.cgi?id=7887). After the
restore they will be re-enabled by hibernation_ops->finish(), but if the
restore fails, they have to be re-enabled by the restore code explicitly.
For this purpose we can introduce two additional hibernation operations,
called pre_restore() and restore_cleanup() and call them from the restore code
path. Still, they should be called if the "platform" mode of hibernation has
been used, so we need to pass the information about the hibernation mode from
the "frozen" kernel to the "boot" kernel in the image header.
Apparently, we can't drop the disabling of GPEs before the restore because of
Bug #7887 . We also can't do it unconditionally, because the GPEs wouldn't
have been enabled after a successful restore if the suspend had been done in
the 'shutdown' or 'reboot' mode.
In principle we could (and probably should) unconditionally disable the GPEs
before each snapshot creation *and* before the restore, but then we'd have to
unconditionally enable them after the snapshot creation as well as after the
restore (or restore failure) Still, for this purpose we'd need to modify
acpi_enter_sleep_state_prep() and acpi_leave_sleep_state() and we'd have to
introduce some mechanism synchronizing the disablind/enabling of the GPEs with
the device drivers' .suspend()/.resume() routines and with
disable_/enable_nonboot_cpus(). However, this would have affected the
suspend (ie. s2ram) code as well as the hibernation, which I'd like to avoid
in this patch series.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Nigel Cunningham <nigel@nigel.suspend2.net>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 10:47:30 +02:00
|
|
|
* @flags: flags to pass to the "boot" kernel in the image header
|
2006-03-23 12:00:00 +01:00
|
|
|
*
|
|
|
|
* It is important _NOT_ to umount filesystems at this point. We want
|
|
|
|
* them synced (in case something goes wrong) but we DO not want to mark
|
|
|
|
* filesystem clean: it is not. (And it does not matter, if we resume
|
|
|
|
* correctly, we'll mark system clean, anyway.)
|
|
|
|
*/
|
|
|
|
|
swsusp: introduce restore platform operations
At least on some machines it is necessary to prepare the ACPI firmware for the
restoration of the system memory state from the hibernation image if the
"platform" mode of hibernation has been used. Namely, in that cases we need
to disable the GPEs before replacing the "boot" kernel with the "frozen"
kernel (cf. http://bugzilla.kernel.org/show_bug.cgi?id=7887). After the
restore they will be re-enabled by hibernation_ops->finish(), but if the
restore fails, they have to be re-enabled by the restore code explicitly.
For this purpose we can introduce two additional hibernation operations,
called pre_restore() and restore_cleanup() and call them from the restore code
path. Still, they should be called if the "platform" mode of hibernation has
been used, so we need to pass the information about the hibernation mode from
the "frozen" kernel to the "boot" kernel in the image header.
Apparently, we can't drop the disabling of GPEs before the restore because of
Bug #7887 . We also can't do it unconditionally, because the GPEs wouldn't
have been enabled after a successful restore if the suspend had been done in
the 'shutdown' or 'reboot' mode.
In principle we could (and probably should) unconditionally disable the GPEs
before each snapshot creation *and* before the restore, but then we'd have to
unconditionally enable them after the snapshot creation as well as after the
restore (or restore failure) Still, for this purpose we'd need to modify
acpi_enter_sleep_state_prep() and acpi_leave_sleep_state() and we'd have to
introduce some mechanism synchronizing the disablind/enabling of the GPEs with
the device drivers' .suspend()/.resume() routines and with
disable_/enable_nonboot_cpus(). However, this would have affected the
suspend (ie. s2ram) code as well as the hibernation, which I'd like to avoid
in this patch series.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Nigel Cunningham <nigel@nigel.suspend2.net>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 10:47:30 +02:00
|
|
|
int swsusp_write(unsigned int flags)
|
2006-03-23 12:00:00 +01:00
|
|
|
{
|
|
|
|
struct swap_map_handle handle;
|
|
|
|
struct snapshot_handle snapshot;
|
|
|
|
struct swsusp_info *header;
|
|
|
|
int error;
|
|
|
|
|
2006-12-07 05:34:10 +01:00
|
|
|
error = swsusp_swap_check();
|
|
|
|
if (error) {
|
2007-12-08 02:09:43 +01:00
|
|
|
printk(KERN_ERR "PM: Cannot find swap device, try "
|
2006-09-26 08:32:44 +02:00
|
|
|
"swapon -a.\n");
|
2006-03-23 12:00:00 +01:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
memset(&snapshot, 0, sizeof(struct snapshot_handle));
|
2010-05-01 23:52:02 +02:00
|
|
|
error = snapshot_read_next(&snapshot);
|
2006-12-07 05:34:10 +01:00
|
|
|
if (error < PAGE_SIZE) {
|
|
|
|
if (error >= 0)
|
|
|
|
error = -EFAULT;
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
}
|
2006-03-23 12:00:00 +01:00
|
|
|
header = (struct swsusp_info *)data_of(snapshot);
|
|
|
|
if (!enough_swap(header->pages)) {
|
2007-12-08 02:09:43 +01:00
|
|
|
printk(KERN_ERR "PM: Not enough free swap\n");
|
2006-12-07 05:34:10 +01:00
|
|
|
error = -ENOSPC;
|
|
|
|
goto out;
|
2006-03-23 12:00:00 +01:00
|
|
|
}
|
|
|
|
error = get_swap_writer(&handle);
|
|
|
|
if (!error) {
|
2006-12-07 05:34:10 +01:00
|
|
|
sector_t start = handle.cur_swap;
|
|
|
|
|
2006-09-26 08:32:42 +02:00
|
|
|
error = swap_write_page(&handle, header, NULL);
|
2006-07-10 13:45:00 +02:00
|
|
|
if (!error)
|
|
|
|
error = save_image(&handle, &snapshot,
|
|
|
|
header->pages - 1);
|
2006-12-07 05:34:10 +01:00
|
|
|
|
2006-07-10 13:45:00 +02:00
|
|
|
if (!error) {
|
|
|
|
flush_swap_writer(&handle);
|
2007-12-08 02:09:43 +01:00
|
|
|
printk(KERN_INFO "PM: S");
|
swsusp: introduce restore platform operations
At least on some machines it is necessary to prepare the ACPI firmware for the
restoration of the system memory state from the hibernation image if the
"platform" mode of hibernation has been used. Namely, in that cases we need
to disable the GPEs before replacing the "boot" kernel with the "frozen"
kernel (cf. http://bugzilla.kernel.org/show_bug.cgi?id=7887). After the
restore they will be re-enabled by hibernation_ops->finish(), but if the
restore fails, they have to be re-enabled by the restore code explicitly.
For this purpose we can introduce two additional hibernation operations,
called pre_restore() and restore_cleanup() and call them from the restore code
path. Still, they should be called if the "platform" mode of hibernation has
been used, so we need to pass the information about the hibernation mode from
the "frozen" kernel to the "boot" kernel in the image header.
Apparently, we can't drop the disabling of GPEs before the restore because of
Bug #7887 . We also can't do it unconditionally, because the GPEs wouldn't
have been enabled after a successful restore if the suspend had been done in
the 'shutdown' or 'reboot' mode.
In principle we could (and probably should) unconditionally disable the GPEs
before each snapshot creation *and* before the restore, but then we'd have to
unconditionally enable them after the snapshot creation as well as after the
restore (or restore failure) Still, for this purpose we'd need to modify
acpi_enter_sleep_state_prep() and acpi_leave_sleep_state() and we'd have to
introduce some mechanism synchronizing the disablind/enabling of the GPEs with
the device drivers' .suspend()/.resume() routines and with
disable_/enable_nonboot_cpus(). However, this would have affected the
suspend (ie. s2ram) code as well as the hibernation, which I'd like to avoid
in this patch series.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Nigel Cunningham <nigel@nigel.suspend2.net>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 10:47:30 +02:00
|
|
|
error = mark_swapfiles(start, flags);
|
2006-07-10 13:45:00 +02:00
|
|
|
printk("|\n");
|
|
|
|
}
|
2006-03-23 12:00:00 +01:00
|
|
|
}
|
|
|
|
if (error)
|
2007-05-06 23:50:47 +02:00
|
|
|
free_all_swap_pages(root_swap);
|
|
|
|
|
2006-03-23 12:00:00 +01:00
|
|
|
release_swap_writer(&handle);
|
2006-12-07 05:34:44 +01:00
|
|
|
out:
|
2007-10-08 19:21:10 +02:00
|
|
|
swsusp_close(FMODE_WRITE);
|
2006-03-23 12:00:00 +01:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The following functions allow us to read data using a swap map
|
|
|
|
* in a file-alike way
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void release_swap_reader(struct swap_map_handle *handle)
|
|
|
|
{
|
|
|
|
if (handle->cur)
|
|
|
|
free_page((unsigned long)handle->cur);
|
|
|
|
handle->cur = NULL;
|
|
|
|
}
|
|
|
|
|
2006-12-07 05:34:10 +01:00
|
|
|
static int get_swap_reader(struct swap_map_handle *handle, sector_t start)
|
2006-03-23 12:00:00 +01:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2006-12-07 05:34:10 +01:00
|
|
|
if (!start)
|
2006-03-23 12:00:00 +01:00
|
|
|
return -EINVAL;
|
2006-12-07 05:34:10 +01:00
|
|
|
|
2006-12-07 05:34:19 +01:00
|
|
|
handle->cur = (struct swap_map_page *)get_zeroed_page(__GFP_WAIT | __GFP_HIGH);
|
2006-03-23 12:00:00 +01:00
|
|
|
if (!handle->cur)
|
|
|
|
return -ENOMEM;
|
2006-12-07 05:34:10 +01:00
|
|
|
|
|
|
|
error = bio_read_page(start, handle->cur, NULL);
|
2006-03-23 12:00:00 +01:00
|
|
|
if (error) {
|
|
|
|
release_swap_reader(handle);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
handle->k = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-26 08:32:44 +02:00
|
|
|
static int swap_read_page(struct swap_map_handle *handle, void *buf,
|
|
|
|
struct bio **bio_chain)
|
2006-03-23 12:00:00 +01:00
|
|
|
{
|
2006-12-07 05:34:10 +01:00
|
|
|
sector_t offset;
|
2006-03-23 12:00:00 +01:00
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!handle->cur)
|
|
|
|
return -EINVAL;
|
|
|
|
offset = handle->cur->entries[handle->k];
|
|
|
|
if (!offset)
|
|
|
|
return -EFAULT;
|
2006-09-26 08:32:44 +02:00
|
|
|
error = bio_read_page(offset, buf, bio_chain);
|
2006-03-23 12:00:00 +01:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
if (++handle->k >= MAP_PAGE_ENTRIES) {
|
2006-09-26 08:32:44 +02:00
|
|
|
error = wait_on_bio_chain(bio_chain);
|
2006-03-23 12:00:00 +01:00
|
|
|
handle->k = 0;
|
|
|
|
offset = handle->cur->next_swap;
|
|
|
|
if (!offset)
|
|
|
|
release_swap_reader(handle);
|
2006-09-26 08:32:44 +02:00
|
|
|
else if (!error)
|
|
|
|
error = bio_read_page(offset, handle->cur, NULL);
|
2006-03-23 12:00:00 +01:00
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* load_image - load the image using the swap map handle
|
|
|
|
* @handle and the snapshot handle @snapshot
|
|
|
|
* (assume there are @nr_pages pages to load)
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int load_image(struct swap_map_handle *handle,
|
|
|
|
struct snapshot_handle *snapshot,
|
2006-09-26 08:32:44 +02:00
|
|
|
unsigned int nr_to_read)
|
2006-03-23 12:00:00 +01:00
|
|
|
{
|
|
|
|
unsigned int m;
|
|
|
|
int error = 0;
|
2006-09-26 08:32:43 +02:00
|
|
|
struct timeval start;
|
|
|
|
struct timeval stop;
|
2006-09-26 08:32:44 +02:00
|
|
|
struct bio *bio;
|
|
|
|
int err2;
|
|
|
|
unsigned nr_pages;
|
2006-03-23 12:00:00 +01:00
|
|
|
|
2007-12-08 02:09:43 +01:00
|
|
|
printk(KERN_INFO "PM: Loading image data pages (%u pages) ... ",
|
|
|
|
nr_to_read);
|
2006-09-26 08:32:44 +02:00
|
|
|
m = nr_to_read / 100;
|
2006-03-23 12:00:00 +01:00
|
|
|
if (!m)
|
|
|
|
m = 1;
|
|
|
|
nr_pages = 0;
|
2006-09-26 08:32:44 +02:00
|
|
|
bio = NULL;
|
2006-09-26 08:32:43 +02:00
|
|
|
do_gettimeofday(&start);
|
2006-09-26 08:32:44 +02:00
|
|
|
for ( ; ; ) {
|
2010-05-01 23:52:02 +02:00
|
|
|
error = snapshot_write_next(snapshot);
|
2006-09-26 08:32:44 +02:00
|
|
|
if (error <= 0)
|
|
|
|
break;
|
|
|
|
error = swap_read_page(handle, data_of(*snapshot), &bio);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
if (snapshot->sync_read)
|
|
|
|
error = wait_on_bio_chain(&bio);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
if (!(nr_pages % m))
|
|
|
|
printk("\b\b\b\b%3d%%", nr_pages / m);
|
|
|
|
nr_pages++;
|
|
|
|
}
|
|
|
|
err2 = wait_on_bio_chain(&bio);
|
2006-09-26 08:32:43 +02:00
|
|
|
do_gettimeofday(&stop);
|
2006-09-26 08:32:44 +02:00
|
|
|
if (!error)
|
|
|
|
error = err2;
|
2006-03-26 11:37:11 +02:00
|
|
|
if (!error) {
|
2006-03-23 12:00:00 +01:00
|
|
|
printk("\b\b\b\bdone\n");
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 05:34:18 +01:00
|
|
|
snapshot_write_finalize(snapshot);
|
2006-03-26 11:37:11 +02:00
|
|
|
if (!snapshot_image_loaded(snapshot))
|
|
|
|
error = -ENODATA;
|
2009-10-28 22:55:42 +01:00
|
|
|
} else
|
|
|
|
printk("\n");
|
2006-12-07 05:34:32 +01:00
|
|
|
swsusp_show_speed(&start, &stop, nr_to_read, "Read");
|
2006-03-23 12:00:00 +01:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
swsusp: introduce restore platform operations
At least on some machines it is necessary to prepare the ACPI firmware for the
restoration of the system memory state from the hibernation image if the
"platform" mode of hibernation has been used. Namely, in that cases we need
to disable the GPEs before replacing the "boot" kernel with the "frozen"
kernel (cf. http://bugzilla.kernel.org/show_bug.cgi?id=7887). After the
restore they will be re-enabled by hibernation_ops->finish(), but if the
restore fails, they have to be re-enabled by the restore code explicitly.
For this purpose we can introduce two additional hibernation operations,
called pre_restore() and restore_cleanup() and call them from the restore code
path. Still, they should be called if the "platform" mode of hibernation has
been used, so we need to pass the information about the hibernation mode from
the "frozen" kernel to the "boot" kernel in the image header.
Apparently, we can't drop the disabling of GPEs before the restore because of
Bug #7887 . We also can't do it unconditionally, because the GPEs wouldn't
have been enabled after a successful restore if the suspend had been done in
the 'shutdown' or 'reboot' mode.
In principle we could (and probably should) unconditionally disable the GPEs
before each snapshot creation *and* before the restore, but then we'd have to
unconditionally enable them after the snapshot creation as well as after the
restore (or restore failure) Still, for this purpose we'd need to modify
acpi_enter_sleep_state_prep() and acpi_leave_sleep_state() and we'd have to
introduce some mechanism synchronizing the disablind/enabling of the GPEs with
the device drivers' .suspend()/.resume() routines and with
disable_/enable_nonboot_cpus(). However, this would have affected the
suspend (ie. s2ram) code as well as the hibernation, which I'd like to avoid
in this patch series.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Nigel Cunningham <nigel@nigel.suspend2.net>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 10:47:30 +02:00
|
|
|
/**
|
|
|
|
* swsusp_read - read the hibernation image.
|
|
|
|
* @flags_p: flags passed by the "frozen" kernel in the image header should
|
|
|
|
* be written into this memeory location
|
|
|
|
*/
|
|
|
|
|
|
|
|
int swsusp_read(unsigned int *flags_p)
|
2006-03-23 12:00:00 +01:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct swap_map_handle handle;
|
|
|
|
struct snapshot_handle snapshot;
|
|
|
|
struct swsusp_info *header;
|
|
|
|
|
swsusp: introduce restore platform operations
At least on some machines it is necessary to prepare the ACPI firmware for the
restoration of the system memory state from the hibernation image if the
"platform" mode of hibernation has been used. Namely, in that cases we need
to disable the GPEs before replacing the "boot" kernel with the "frozen"
kernel (cf. http://bugzilla.kernel.org/show_bug.cgi?id=7887). After the
restore they will be re-enabled by hibernation_ops->finish(), but if the
restore fails, they have to be re-enabled by the restore code explicitly.
For this purpose we can introduce two additional hibernation operations,
called pre_restore() and restore_cleanup() and call them from the restore code
path. Still, they should be called if the "platform" mode of hibernation has
been used, so we need to pass the information about the hibernation mode from
the "frozen" kernel to the "boot" kernel in the image header.
Apparently, we can't drop the disabling of GPEs before the restore because of
Bug #7887 . We also can't do it unconditionally, because the GPEs wouldn't
have been enabled after a successful restore if the suspend had been done in
the 'shutdown' or 'reboot' mode.
In principle we could (and probably should) unconditionally disable the GPEs
before each snapshot creation *and* before the restore, but then we'd have to
unconditionally enable them after the snapshot creation as well as after the
restore (or restore failure) Still, for this purpose we'd need to modify
acpi_enter_sleep_state_prep() and acpi_leave_sleep_state() and we'd have to
introduce some mechanism synchronizing the disablind/enabling of the GPEs with
the device drivers' .suspend()/.resume() routines and with
disable_/enable_nonboot_cpus(). However, this would have affected the
suspend (ie. s2ram) code as well as the hibernation, which I'd like to avoid
in this patch series.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Nigel Cunningham <nigel@nigel.suspend2.net>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 10:47:30 +02:00
|
|
|
*flags_p = swsusp_header->flags;
|
2006-03-23 12:00:00 +01:00
|
|
|
|
|
|
|
memset(&snapshot, 0, sizeof(struct snapshot_handle));
|
2010-05-01 23:52:02 +02:00
|
|
|
error = snapshot_write_next(&snapshot);
|
2006-03-23 12:00:00 +01:00
|
|
|
if (error < PAGE_SIZE)
|
|
|
|
return error < 0 ? error : -EFAULT;
|
|
|
|
header = (struct swsusp_info *)data_of(snapshot);
|
2007-05-02 19:27:07 +02:00
|
|
|
error = get_swap_reader(&handle, swsusp_header->image);
|
2006-03-23 12:00:00 +01:00
|
|
|
if (!error)
|
2006-09-26 08:32:44 +02:00
|
|
|
error = swap_read_page(&handle, header, NULL);
|
2006-03-23 12:00:00 +01:00
|
|
|
if (!error)
|
|
|
|
error = load_image(&handle, &snapshot, header->pages - 1);
|
|
|
|
release_swap_reader(&handle);
|
|
|
|
|
|
|
|
if (!error)
|
2007-12-08 02:09:43 +01:00
|
|
|
pr_debug("PM: Image successfully loaded\n");
|
2006-03-23 12:00:00 +01:00
|
|
|
else
|
2007-12-08 02:09:43 +01:00
|
|
|
pr_debug("PM: Error %d resuming\n", error);
|
2006-03-23 12:00:00 +01:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* swsusp_check - Check for swsusp signature in the resume device
|
|
|
|
*/
|
|
|
|
|
|
|
|
int swsusp_check(void)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
resume_bdev = open_by_devnum(swsusp_resume_device, FMODE_READ);
|
|
|
|
if (!IS_ERR(resume_bdev)) {
|
|
|
|
set_blocksize(resume_bdev, PAGE_SIZE);
|
2007-05-23 22:58:00 +02:00
|
|
|
memset(swsusp_header, 0, PAGE_SIZE);
|
2006-12-07 05:34:12 +01:00
|
|
|
error = bio_read_page(swsusp_resume_block,
|
2007-05-02 19:27:07 +02:00
|
|
|
swsusp_header, NULL);
|
2006-12-07 05:34:12 +01:00
|
|
|
if (error)
|
2009-10-07 22:37:35 +02:00
|
|
|
goto put;
|
2006-12-07 05:34:12 +01:00
|
|
|
|
2007-05-02 19:27:07 +02:00
|
|
|
if (!memcmp(SWSUSP_SIG, swsusp_header->sig, 10)) {
|
|
|
|
memcpy(swsusp_header->sig, swsusp_header->orig_sig, 10);
|
2006-03-23 12:00:00 +01:00
|
|
|
/* Reset swap signature now */
|
2006-12-07 05:34:12 +01:00
|
|
|
error = bio_write_page(swsusp_resume_block,
|
2007-05-02 19:27:07 +02:00
|
|
|
swsusp_header, NULL);
|
2006-03-23 12:00:00 +01:00
|
|
|
} else {
|
2009-10-07 22:37:35 +02:00
|
|
|
error = -EINVAL;
|
2006-03-23 12:00:00 +01:00
|
|
|
}
|
2009-10-07 22:37:35 +02:00
|
|
|
|
|
|
|
put:
|
2006-03-23 12:00:00 +01:00
|
|
|
if (error)
|
2008-02-23 02:40:24 +01:00
|
|
|
blkdev_put(resume_bdev, FMODE_READ);
|
2006-03-23 12:00:00 +01:00
|
|
|
else
|
2007-12-08 02:09:43 +01:00
|
|
|
pr_debug("PM: Signature found, resuming\n");
|
2006-03-23 12:00:00 +01:00
|
|
|
} else {
|
|
|
|
error = PTR_ERR(resume_bdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (error)
|
2007-12-08 02:09:43 +01:00
|
|
|
pr_debug("PM: Error %d checking image file\n", error);
|
2006-03-23 12:00:00 +01:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* swsusp_close - close swap device.
|
|
|
|
*/
|
|
|
|
|
2007-10-08 19:21:10 +02:00
|
|
|
void swsusp_close(fmode_t mode)
|
2006-03-23 12:00:00 +01:00
|
|
|
{
|
|
|
|
if (IS_ERR(resume_bdev)) {
|
2007-12-08 02:09:43 +01:00
|
|
|
pr_debug("PM: Image device not initialised\n");
|
2006-03-23 12:00:00 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-30 07:47:12 +01:00
|
|
|
blkdev_put(resume_bdev, mode);
|
2006-03-23 12:00:00 +01:00
|
|
|
}
|
2007-05-02 19:27:07 +02:00
|
|
|
|
|
|
|
static int swsusp_header_init(void)
|
|
|
|
{
|
|
|
|
swsusp_header = (struct swsusp_header*) __get_free_page(GFP_KERNEL);
|
|
|
|
if (!swsusp_header)
|
|
|
|
panic("Could not allocate memory for swsusp_header\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
core_initcall(swsusp_header_init);
|