2005-10-30 15:59:56 -07:00
|
|
|
/*
|
2005-10-30 15:59:58 -07:00
|
|
|
* linux/kernel/power/snapshot.c
|
2005-10-30 15:59:56 -07:00
|
|
|
*
|
[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-06 21:34:18 -07:00
|
|
|
* This file provides system snapshot/restore functionality for swsusp.
|
2005-10-30 15:59:56 -07:00
|
|
|
*
|
2010-07-18 06:27:13 -06:00
|
|
|
* Copyright (C) 1998-2005 Pavel Machek <pavel@ucw.cz>
|
[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-06 21:34:18 -07:00
|
|
|
* Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
|
2005-10-30 15:59:56 -07:00
|
|
|
*
|
[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-06 21:34:18 -07:00
|
|
|
* This file is released under the GPLv2.
|
2005-10-30 15:59:56 -07:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2006-03-23 03:59:59 -07:00
|
|
|
#include <linux/version.h>
|
2005-10-30 15:59:56 -07:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/suspend.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/pm.h>
|
|
|
|
#include <linux/device.h>
|
2007-05-06 15:50:43 -06:00
|
|
|
#include <linux/init.h>
|
2005-10-30 15:59:56 -07:00
|
|
|
#include <linux/bootmem.h>
|
|
|
|
#include <linux/syscalls.h>
|
|
|
|
#include <linux/console.h>
|
|
|
|
#include <linux/highmem.h>
|
2008-11-26 16:00:24 -07:00
|
|
|
#include <linux/list.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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2005-10-30 15:59:56 -07:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/mmu_context.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/tlbflush.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
|
|
|
|
#include "power.h"
|
|
|
|
|
2007-05-06 15:50:43 -06:00
|
|
|
static int swsusp_page_is_free(struct page *);
|
|
|
|
static void swsusp_set_page_forbidden(struct page *);
|
|
|
|
static void swsusp_unset_page_forbidden(struct page *);
|
|
|
|
|
2011-05-15 03:38:48 -06:00
|
|
|
/*
|
|
|
|
* Number of bytes to reserve for memory allocations made by device drivers
|
|
|
|
* from their ->freeze() and ->freeze_noirq() callbacks so that they don't
|
|
|
|
* cause image creation to fail (tunable via /sys/power/reserved_size).
|
|
|
|
*/
|
|
|
|
unsigned long reserved_size;
|
|
|
|
|
|
|
|
void __init hibernate_reserved_size_init(void)
|
|
|
|
{
|
|
|
|
reserved_size = SPARE_PAGES * PAGE_SIZE;
|
|
|
|
}
|
|
|
|
|
2009-06-11 15:11:17 -06:00
|
|
|
/*
|
|
|
|
* Preferred image size in bytes (tunable via /sys/power/image_size).
|
2011-05-15 03:39:48 -06:00
|
|
|
* When it is set to N, swsusp will do its best to ensure the image
|
|
|
|
* size will not exceed N bytes, but if that is impossible, it will
|
|
|
|
* try to create the smallest image possible.
|
2009-06-11 15:11:17 -06:00
|
|
|
*/
|
2010-09-20 11:44:56 -06:00
|
|
|
unsigned long image_size;
|
|
|
|
|
|
|
|
void __init hibernate_image_size_init(void)
|
|
|
|
{
|
2011-05-15 03:39:48 -06:00
|
|
|
image_size = ((totalram_pages * 2) / 5) * PAGE_SIZE;
|
2010-09-20 11:44:56 -06:00
|
|
|
}
|
2009-06-11 15:11:17 -06:00
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
/* List of PBEs needed for restoring the pages that were allocated before
|
|
|
|
* the suspend and included in the suspend image, but have also been
|
|
|
|
* allocated by the "resume" kernel, so their contents cannot be written
|
|
|
|
* directly to their "original" page frames.
|
|
|
|
*/
|
2006-09-26 00:32:52 -06:00
|
|
|
struct pbe *restore_pblist;
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
/* Pointer to an auxiliary buffer (1 page) */
|
[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 00:32:55 -06:00
|
|
|
static void *buffer;
|
2006-01-06 01:13:05 -07:00
|
|
|
|
2006-09-26 00:32:50 -06:00
|
|
|
/**
|
|
|
|
* @safe_needed - on resume, for storing the PBE list and the image,
|
|
|
|
* we can only use memory pages that do not conflict with the pages
|
[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-06 21:34:18 -07:00
|
|
|
* used before suspend. The unsafe pages have PageNosaveFree set
|
|
|
|
* and we count them using unsafe_pages.
|
2006-09-26 00:32:50 -06:00
|
|
|
*
|
[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-06 21:34:18 -07:00
|
|
|
* Each allocated image page is marked as PageNosave and PageNosaveFree
|
|
|
|
* so that swsusp_free() can release it.
|
2006-09-26 00:32:50 -06:00
|
|
|
*/
|
|
|
|
|
2006-09-26 00:32:52 -06:00
|
|
|
#define PG_ANY 0
|
|
|
|
#define PG_SAFE 1
|
|
|
|
#define PG_UNSAFE_CLEAR 1
|
|
|
|
#define PG_UNSAFE_KEEP 0
|
|
|
|
|
[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 00:32:55 -06:00
|
|
|
static unsigned int allocated_unsafe_pages;
|
2006-09-26 00:32:50 -06:00
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
static void *get_image_page(gfp_t gfp_mask, int safe_needed)
|
2006-09-26 00:32:50 -06:00
|
|
|
{
|
|
|
|
void *res;
|
|
|
|
|
|
|
|
res = (void *)get_zeroed_page(gfp_mask);
|
|
|
|
if (safe_needed)
|
2007-05-06 15:50:42 -06:00
|
|
|
while (res && swsusp_page_is_free(virt_to_page(res))) {
|
2006-09-26 00:32:50 -06:00
|
|
|
/* The page is unsafe, mark it for swsusp_free() */
|
2007-05-06 15:50:42 -06:00
|
|
|
swsusp_set_page_forbidden(virt_to_page(res));
|
[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 00:32:55 -06:00
|
|
|
allocated_unsafe_pages++;
|
2006-09-26 00:32:50 -06:00
|
|
|
res = (void *)get_zeroed_page(gfp_mask);
|
|
|
|
}
|
|
|
|
if (res) {
|
2007-05-06 15:50:42 -06:00
|
|
|
swsusp_set_page_forbidden(virt_to_page(res));
|
|
|
|
swsusp_set_page_free(virt_to_page(res));
|
2006-09-26 00:32:50 -06:00
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long get_safe_page(gfp_t gfp_mask)
|
|
|
|
{
|
[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-06 21:34:18 -07:00
|
|
|
return (unsigned long)get_image_page(gfp_mask, PG_SAFE);
|
|
|
|
}
|
|
|
|
|
2006-12-06 21:34:43 -07:00
|
|
|
static struct page *alloc_image_page(gfp_t gfp_mask)
|
|
|
|
{
|
[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-06 21:34:18 -07:00
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = alloc_page(gfp_mask);
|
|
|
|
if (page) {
|
2007-05-06 15:50:42 -06:00
|
|
|
swsusp_set_page_forbidden(page);
|
|
|
|
swsusp_set_page_free(page);
|
[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-06 21:34:18 -07:00
|
|
|
}
|
|
|
|
return page;
|
2006-09-26 00:32:50 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* free_image_page - free page represented by @addr, allocated with
|
[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-06 21:34:18 -07:00
|
|
|
* get_image_page (page flags set by it must be cleared)
|
2006-09-26 00:32:50 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
static inline void free_image_page(void *addr, int clear_nosave_free)
|
|
|
|
{
|
[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-06 21:34:18 -07:00
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
BUG_ON(!virt_addr_valid(addr));
|
|
|
|
|
|
|
|
page = virt_to_page(addr);
|
|
|
|
|
2007-05-06 15:50:42 -06:00
|
|
|
swsusp_unset_page_forbidden(page);
|
2006-09-26 00:32:50 -06:00
|
|
|
if (clear_nosave_free)
|
2007-05-06 15:50:42 -06:00
|
|
|
swsusp_unset_page_free(page);
|
[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-06 21:34:18 -07:00
|
|
|
|
|
|
|
__free_page(page);
|
2006-09-26 00:32:50 -06:00
|
|
|
}
|
|
|
|
|
2006-09-26 00:32:54 -06:00
|
|
|
/* struct linked_page is used to build chains of pages */
|
|
|
|
|
|
|
|
#define LINKED_PAGE_DATA_SIZE (PAGE_SIZE - sizeof(void *))
|
|
|
|
|
|
|
|
struct linked_page {
|
|
|
|
struct linked_page *next;
|
|
|
|
char data[LINKED_PAGE_DATA_SIZE];
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
free_list_of_pages(struct linked_page *list, int clear_page_nosave)
|
|
|
|
{
|
|
|
|
while (list) {
|
|
|
|
struct linked_page *lp = list->next;
|
|
|
|
|
|
|
|
free_image_page(list, clear_page_nosave);
|
|
|
|
list = lp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct chain_allocator is used for allocating small objects out of
|
|
|
|
* a linked list of pages called 'the chain'.
|
|
|
|
*
|
|
|
|
* The chain grows each time when there is no room for a new object in
|
|
|
|
* the current page. The allocated objects cannot be freed individually.
|
|
|
|
* It is only possible to free them all at once, by freeing the entire
|
|
|
|
* chain.
|
|
|
|
*
|
|
|
|
* NOTE: The chain allocator may be inefficient if the allocated objects
|
|
|
|
* are not much smaller than PAGE_SIZE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct chain_allocator {
|
|
|
|
struct linked_page *chain; /* the chain */
|
|
|
|
unsigned int used_space; /* total size of objects allocated out
|
|
|
|
* of the current page
|
|
|
|
*/
|
|
|
|
gfp_t gfp_mask; /* mask for allocating pages */
|
|
|
|
int safe_needed; /* if set, only "safe" pages are allocated */
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
chain_init(struct chain_allocator *ca, gfp_t gfp_mask, int safe_needed)
|
|
|
|
{
|
|
|
|
ca->chain = NULL;
|
|
|
|
ca->used_space = LINKED_PAGE_DATA_SIZE;
|
|
|
|
ca->gfp_mask = gfp_mask;
|
|
|
|
ca->safe_needed = safe_needed;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *chain_alloc(struct chain_allocator *ca, unsigned int size)
|
|
|
|
{
|
|
|
|
void *ret;
|
|
|
|
|
|
|
|
if (LINKED_PAGE_DATA_SIZE - ca->used_space < size) {
|
|
|
|
struct linked_page *lp;
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
lp = get_image_page(ca->gfp_mask, ca->safe_needed);
|
2006-09-26 00:32:54 -06:00
|
|
|
if (!lp)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
lp->next = ca->chain;
|
|
|
|
ca->chain = lp;
|
|
|
|
ca->used_space = 0;
|
|
|
|
}
|
|
|
|
ret = ca->chain->data + ca->used_space;
|
|
|
|
ca->used_space += size;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Data types related to memory bitmaps.
|
|
|
|
*
|
|
|
|
* Memory bitmap is a structure consiting of many linked lists of
|
|
|
|
* objects. The main list's elements are of type struct zone_bitmap
|
|
|
|
* and each of them corresonds to one zone. For each zone bitmap
|
|
|
|
* object there is a list of objects of type struct bm_block that
|
2008-07-23 22:28:38 -06:00
|
|
|
* represent each blocks of bitmap in which information is stored.
|
2006-09-26 00:32:54 -06:00
|
|
|
*
|
|
|
|
* struct memory_bitmap contains a pointer to the main list of zone
|
|
|
|
* bitmap objects, a struct bm_position used for browsing the bitmap,
|
|
|
|
* and a pointer to the list of pages used for allocating all of the
|
|
|
|
* zone bitmap objects and bitmap block objects.
|
|
|
|
*
|
|
|
|
* NOTE: It has to be possible to lay out the bitmap in memory
|
|
|
|
* using only allocations of order 0. Additionally, the bitmap is
|
|
|
|
* designed to work with arbitrary number of zones (this is over the
|
|
|
|
* top for now, but let's avoid making unnecessary assumptions ;-).
|
|
|
|
*
|
|
|
|
* struct zone_bitmap contains a pointer to a list of bitmap block
|
|
|
|
* objects and a pointer to the bitmap block object that has been
|
|
|
|
* most recently used for setting bits. Additionally, it contains the
|
|
|
|
* pfns that correspond to the start and end of the represented zone.
|
|
|
|
*
|
|
|
|
* struct bm_block contains a pointer to the memory page in which
|
2008-07-23 22:28:38 -06:00
|
|
|
* information is stored (in the form of a block of bitmap)
|
|
|
|
* It also contains the pfns that correspond to the start and end of
|
|
|
|
* the represented memory area.
|
2006-09-26 00:32:54 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
#define BM_END_OF_MAP (~0UL)
|
|
|
|
|
2009-07-22 11:56:10 -06:00
|
|
|
#define BM_BITS_PER_BLOCK (PAGE_SIZE * BITS_PER_BYTE)
|
2006-09-26 00:32:54 -06:00
|
|
|
|
|
|
|
struct bm_block {
|
2008-11-26 16:00:24 -07:00
|
|
|
struct list_head hook; /* hook into a list of bitmap blocks */
|
2006-09-26 00:32:54 -06:00
|
|
|
unsigned long start_pfn; /* pfn represented by the first bit */
|
|
|
|
unsigned long end_pfn; /* pfn represented by the last bit plus 1 */
|
2008-07-23 22:28:38 -06:00
|
|
|
unsigned long *data; /* bitmap representing pages */
|
2006-09-26 00:32:54 -06:00
|
|
|
};
|
|
|
|
|
2008-07-23 22:28:38 -06:00
|
|
|
static inline unsigned long bm_block_bits(struct bm_block *bb)
|
|
|
|
{
|
|
|
|
return bb->end_pfn - bb->start_pfn;
|
|
|
|
}
|
|
|
|
|
2006-09-26 00:32:54 -06:00
|
|
|
/* strcut bm_position is used for browsing memory bitmaps */
|
|
|
|
|
|
|
|
struct bm_position {
|
|
|
|
struct bm_block *block;
|
|
|
|
int bit;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct memory_bitmap {
|
2008-11-26 16:00:24 -07:00
|
|
|
struct list_head blocks; /* list of bitmap blocks */
|
2006-09-26 00:32:54 -06:00
|
|
|
struct linked_page *p_list; /* list of pages used to store zone
|
|
|
|
* bitmap objects and bitmap block
|
|
|
|
* objects
|
|
|
|
*/
|
|
|
|
struct bm_position cur; /* most recently used bit position */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Functions that operate on memory bitmaps */
|
|
|
|
|
|
|
|
static void memory_bm_position_reset(struct memory_bitmap *bm)
|
|
|
|
{
|
2008-11-26 16:00:24 -07:00
|
|
|
bm->cur.block = list_entry(bm->blocks.next, struct bm_block, hook);
|
2008-07-23 22:28:38 -06:00
|
|
|
bm->cur.bit = 0;
|
2006-09-26 00:32:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void memory_bm_free(struct memory_bitmap *bm, int clear_nosave_free);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* create_bm_block_list - create a list of block bitmap objects
|
2009-07-22 11:56:10 -06:00
|
|
|
* @pages - number of pages to track
|
2008-11-26 16:00:24 -07:00
|
|
|
* @list - list to put the allocated blocks into
|
|
|
|
* @ca - chain allocator to be used for allocating memory
|
2006-09-26 00:32:54 -06:00
|
|
|
*/
|
2008-11-26 16:00:24 -07:00
|
|
|
static int create_bm_block_list(unsigned long pages,
|
|
|
|
struct list_head *list,
|
|
|
|
struct chain_allocator *ca)
|
2006-09-26 00:32:54 -06:00
|
|
|
{
|
2008-11-26 16:00:24 -07:00
|
|
|
unsigned int nr_blocks = DIV_ROUND_UP(pages, BM_BITS_PER_BLOCK);
|
2006-09-26 00:32:54 -06:00
|
|
|
|
|
|
|
while (nr_blocks-- > 0) {
|
|
|
|
struct bm_block *bb;
|
|
|
|
|
|
|
|
bb = chain_alloc(ca, sizeof(struct bm_block));
|
|
|
|
if (!bb)
|
2008-11-26 16:00:24 -07:00
|
|
|
return -ENOMEM;
|
|
|
|
list_add(&bb->hook, list);
|
2006-09-26 00:32:54 -06:00
|
|
|
}
|
2008-11-26 16:00:24 -07:00
|
|
|
|
|
|
|
return 0;
|
2006-09-26 00:32:54 -06:00
|
|
|
}
|
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
struct mem_extent {
|
|
|
|
struct list_head hook;
|
|
|
|
unsigned long start;
|
|
|
|
unsigned long end;
|
|
|
|
};
|
|
|
|
|
2006-09-26 00:32:54 -06:00
|
|
|
/**
|
2008-11-26 16:00:24 -07:00
|
|
|
* free_mem_extents - free a list of memory extents
|
|
|
|
* @list - list of extents to empty
|
2006-09-26 00:32:54 -06:00
|
|
|
*/
|
2008-11-26 16:00:24 -07:00
|
|
|
static void free_mem_extents(struct list_head *list)
|
|
|
|
{
|
|
|
|
struct mem_extent *ext, *aux;
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
list_for_each_entry_safe(ext, aux, list, hook) {
|
|
|
|
list_del(&ext->hook);
|
|
|
|
kfree(ext);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* create_mem_extents - create a list of memory extents representing
|
|
|
|
* contiguous ranges of PFNs
|
|
|
|
* @list - list to put the extents into
|
|
|
|
* @gfp_mask - mask to use for memory allocations
|
|
|
|
*/
|
|
|
|
static int create_mem_extents(struct list_head *list, gfp_t gfp_mask)
|
2006-09-26 00:32:54 -06:00
|
|
|
{
|
2008-11-26 16:00:24 -07:00
|
|
|
struct zone *zone;
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
INIT_LIST_HEAD(list);
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2009-03-31 16:19:31 -06:00
|
|
|
for_each_populated_zone(zone) {
|
2008-11-26 16:00:24 -07:00
|
|
|
unsigned long zone_start, zone_end;
|
|
|
|
struct mem_extent *ext, *cur, *aux;
|
|
|
|
|
|
|
|
zone_start = zone->zone_start_pfn;
|
2013-09-11 15:21:44 -06:00
|
|
|
zone_end = zone_end_pfn(zone);
|
2008-11-26 16:00:24 -07:00
|
|
|
|
|
|
|
list_for_each_entry(ext, list, hook)
|
|
|
|
if (zone_start <= ext->end)
|
|
|
|
break;
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
if (&ext->hook == list || zone_end < ext->start) {
|
|
|
|
/* New extent is necessary */
|
|
|
|
struct mem_extent *new_ext;
|
|
|
|
|
|
|
|
new_ext = kzalloc(sizeof(struct mem_extent), gfp_mask);
|
|
|
|
if (!new_ext) {
|
|
|
|
free_mem_extents(list);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
new_ext->start = zone_start;
|
|
|
|
new_ext->end = zone_end;
|
|
|
|
list_add_tail(&new_ext->hook, &ext->hook);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Merge this zone's range of PFNs with the existing one */
|
|
|
|
if (zone_start < ext->start)
|
|
|
|
ext->start = zone_start;
|
|
|
|
if (zone_end > ext->end)
|
|
|
|
ext->end = zone_end;
|
|
|
|
|
|
|
|
/* More merging may be possible */
|
|
|
|
cur = ext;
|
|
|
|
list_for_each_entry_safe_continue(cur, aux, list, hook) {
|
|
|
|
if (zone_end < cur->start)
|
|
|
|
break;
|
|
|
|
if (zone_end < cur->end)
|
|
|
|
ext->end = cur->end;
|
|
|
|
list_del(&cur->hook);
|
|
|
|
kfree(cur);
|
|
|
|
}
|
2006-09-26 00:32:54 -06:00
|
|
|
}
|
2008-11-26 16:00:24 -07:00
|
|
|
|
|
|
|
return 0;
|
2006-09-26 00:32:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* memory_bm_create - allocate memory for a memory bitmap
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
memory_bm_create(struct memory_bitmap *bm, gfp_t gfp_mask, int safe_needed)
|
|
|
|
{
|
|
|
|
struct chain_allocator ca;
|
2008-11-26 16:00:24 -07:00
|
|
|
struct list_head mem_extents;
|
|
|
|
struct mem_extent *ext;
|
|
|
|
int error;
|
2006-09-26 00:32:54 -06:00
|
|
|
|
|
|
|
chain_init(&ca, gfp_mask, safe_needed);
|
2008-11-26 16:00:24 -07:00
|
|
|
INIT_LIST_HEAD(&bm->blocks);
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
error = create_mem_extents(&mem_extents, gfp_mask);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
list_for_each_entry(ext, &mem_extents, hook) {
|
|
|
|
struct bm_block *bb;
|
|
|
|
unsigned long pfn = ext->start;
|
|
|
|
unsigned long pages = ext->end - ext->start;
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
bb = list_entry(bm->blocks.prev, struct bm_block, hook);
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
error = create_bm_block_list(pages, bm->blocks.prev, &ca);
|
|
|
|
if (error)
|
|
|
|
goto Error;
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
list_for_each_entry_continue(bb, &bm->blocks, hook) {
|
|
|
|
bb->data = get_image_page(gfp_mask, safe_needed);
|
|
|
|
if (!bb->data) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto Error;
|
|
|
|
}
|
2006-09-26 00:32:54 -06:00
|
|
|
|
|
|
|
bb->start_pfn = pfn;
|
2008-11-26 16:00:24 -07:00
|
|
|
if (pages >= BM_BITS_PER_BLOCK) {
|
2006-09-26 00:32:54 -06:00
|
|
|
pfn += BM_BITS_PER_BLOCK;
|
2008-11-26 16:00:24 -07:00
|
|
|
pages -= BM_BITS_PER_BLOCK;
|
2006-09-26 00:32:54 -06:00
|
|
|
} else {
|
|
|
|
/* This is executed only once in the loop */
|
2008-11-26 16:00:24 -07:00
|
|
|
pfn += pages;
|
2006-09-26 00:32:54 -06:00
|
|
|
}
|
|
|
|
bb->end_pfn = pfn;
|
|
|
|
}
|
|
|
|
}
|
2008-11-26 16:00:24 -07:00
|
|
|
|
2006-09-26 00:32:54 -06:00
|
|
|
bm->p_list = ca.chain;
|
|
|
|
memory_bm_position_reset(bm);
|
2008-11-26 16:00:24 -07:00
|
|
|
Exit:
|
|
|
|
free_mem_extents(&mem_extents);
|
|
|
|
return error;
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
Error:
|
2006-09-26 00:32:54 -06:00
|
|
|
bm->p_list = ca.chain;
|
|
|
|
memory_bm_free(bm, PG_UNSAFE_CLEAR);
|
2008-11-26 16:00:24 -07:00
|
|
|
goto Exit;
|
2006-09-26 00:32:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* memory_bm_free - free memory occupied by the memory bitmap @bm
|
|
|
|
*/
|
|
|
|
static void memory_bm_free(struct memory_bitmap *bm, int clear_nosave_free)
|
|
|
|
{
|
2008-11-26 16:00:24 -07:00
|
|
|
struct bm_block *bb;
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
list_for_each_entry(bb, &bm->blocks, hook)
|
|
|
|
if (bb->data)
|
|
|
|
free_image_page(bb->data, clear_nosave_free);
|
2006-09-26 00:32:54 -06:00
|
|
|
|
|
|
|
free_list_of_pages(bm->p_list, clear_nosave_free);
|
2008-11-26 16:00:24 -07:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&bm->blocks);
|
2006-09-26 00:32:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-05-06 15:50:43 -06:00
|
|
|
* memory_bm_find_bit - find the bit in the bitmap @bm that corresponds
|
2006-09-26 00:32:54 -06:00
|
|
|
* to given pfn. The cur_zone_bm member of @bm and the cur_block member
|
|
|
|
* of @bm->cur_zone_bm are updated.
|
|
|
|
*/
|
2008-03-11 17:34:57 -06:00
|
|
|
static int memory_bm_find_bit(struct memory_bitmap *bm, unsigned long pfn,
|
2007-05-06 15:50:43 -06:00
|
|
|
void **addr, unsigned int *bit_nr)
|
2006-09-26 00:32:54 -06:00
|
|
|
{
|
|
|
|
struct bm_block *bb;
|
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
/*
|
|
|
|
* Check if the pfn corresponds to the current bitmap block and find
|
|
|
|
* the block where it fits if this is not the case.
|
|
|
|
*/
|
|
|
|
bb = bm->cur.block;
|
2006-09-26 00:32:54 -06:00
|
|
|
if (pfn < bb->start_pfn)
|
2008-11-26 16:00:24 -07:00
|
|
|
list_for_each_entry_continue_reverse(bb, &bm->blocks, hook)
|
|
|
|
if (pfn >= bb->start_pfn)
|
|
|
|
break;
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
if (pfn >= bb->end_pfn)
|
|
|
|
list_for_each_entry_continue(bb, &bm->blocks, hook)
|
|
|
|
if (pfn >= bb->start_pfn && pfn < bb->end_pfn)
|
|
|
|
break;
|
2007-05-06 15:50:43 -06:00
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
if (&bb->hook == &bm->blocks)
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
/* The block has been found */
|
|
|
|
bm->cur.block = bb;
|
2006-09-26 00:32:54 -06:00
|
|
|
pfn -= bb->start_pfn;
|
2008-11-26 16:00:24 -07:00
|
|
|
bm->cur.bit = pfn + 1;
|
2008-07-23 22:28:38 -06:00
|
|
|
*bit_nr = pfn;
|
|
|
|
*addr = bb->data;
|
2008-03-11 17:34:57 -06:00
|
|
|
return 0;
|
2007-05-06 15:50:43 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void memory_bm_set_bit(struct memory_bitmap *bm, unsigned long pfn)
|
|
|
|
{
|
|
|
|
void *addr;
|
|
|
|
unsigned int bit;
|
2008-03-11 17:34:57 -06:00
|
|
|
int error;
|
2007-05-06 15:50:43 -06:00
|
|
|
|
2008-03-11 17:34:57 -06:00
|
|
|
error = memory_bm_find_bit(bm, pfn, &addr, &bit);
|
|
|
|
BUG_ON(error);
|
2007-05-06 15:50:43 -06:00
|
|
|
set_bit(bit, addr);
|
|
|
|
}
|
|
|
|
|
2008-03-11 17:34:57 -06:00
|
|
|
static int mem_bm_set_bit_check(struct memory_bitmap *bm, unsigned long pfn)
|
|
|
|
{
|
|
|
|
void *addr;
|
|
|
|
unsigned int bit;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = memory_bm_find_bit(bm, pfn, &addr, &bit);
|
|
|
|
if (!error)
|
|
|
|
set_bit(bit, addr);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-05-06 15:50:43 -06:00
|
|
|
static void memory_bm_clear_bit(struct memory_bitmap *bm, unsigned long pfn)
|
|
|
|
{
|
|
|
|
void *addr;
|
|
|
|
unsigned int bit;
|
2008-03-11 17:34:57 -06:00
|
|
|
int error;
|
2007-05-06 15:50:43 -06:00
|
|
|
|
2008-03-11 17:34:57 -06:00
|
|
|
error = memory_bm_find_bit(bm, pfn, &addr, &bit);
|
|
|
|
BUG_ON(error);
|
2007-05-06 15:50:43 -06:00
|
|
|
clear_bit(bit, addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int memory_bm_test_bit(struct memory_bitmap *bm, unsigned long pfn)
|
|
|
|
{
|
|
|
|
void *addr;
|
|
|
|
unsigned int bit;
|
2008-03-11 17:34:57 -06:00
|
|
|
int error;
|
2007-05-06 15:50:43 -06:00
|
|
|
|
2008-03-11 17:34:57 -06:00
|
|
|
error = memory_bm_find_bit(bm, pfn, &addr, &bit);
|
|
|
|
BUG_ON(error);
|
2007-05-06 15:50:43 -06:00
|
|
|
return test_bit(bit, addr);
|
2006-09-26 00:32:54 -06:00
|
|
|
}
|
|
|
|
|
2008-11-11 13:32:44 -07:00
|
|
|
static bool memory_bm_pfn_present(struct memory_bitmap *bm, unsigned long pfn)
|
|
|
|
{
|
|
|
|
void *addr;
|
|
|
|
unsigned int bit;
|
|
|
|
|
|
|
|
return !memory_bm_find_bit(bm, pfn, &addr, &bit);
|
|
|
|
}
|
|
|
|
|
2006-09-26 00:32:54 -06:00
|
|
|
/**
|
|
|
|
* memory_bm_next_pfn - find the pfn that corresponds to the next set bit
|
|
|
|
* in the bitmap @bm. If the pfn cannot be found, BM_END_OF_MAP is
|
|
|
|
* returned.
|
|
|
|
*
|
|
|
|
* It is required to run memory_bm_position_reset() before the first call to
|
|
|
|
* this function.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned long memory_bm_next_pfn(struct memory_bitmap *bm)
|
|
|
|
{
|
|
|
|
struct bm_block *bb;
|
|
|
|
int bit;
|
|
|
|
|
2008-11-26 16:00:24 -07:00
|
|
|
bb = bm->cur.block;
|
2006-09-26 00:32:54 -06:00
|
|
|
do {
|
2008-11-26 16:00:24 -07:00
|
|
|
bit = bm->cur.bit;
|
|
|
|
bit = find_next_bit(bb->data, bm_block_bits(bb), bit);
|
|
|
|
if (bit < bm_block_bits(bb))
|
|
|
|
goto Return_pfn;
|
|
|
|
|
|
|
|
bb = list_entry(bb->hook.next, struct bm_block, hook);
|
|
|
|
bm->cur.block = bb;
|
|
|
|
bm->cur.bit = 0;
|
|
|
|
} while (&bb->hook != &bm->blocks);
|
|
|
|
|
2006-09-26 00:32:54 -06:00
|
|
|
memory_bm_position_reset(bm);
|
|
|
|
return BM_END_OF_MAP;
|
|
|
|
|
2006-12-06 21:34:44 -07:00
|
|
|
Return_pfn:
|
2008-07-23 22:28:38 -06:00
|
|
|
bm->cur.bit = bit + 1;
|
|
|
|
return bb->start_pfn + bit;
|
2006-09-26 00:32:54 -06:00
|
|
|
}
|
|
|
|
|
2007-05-06 15:50:43 -06:00
|
|
|
/**
|
|
|
|
* This structure represents a range of page frames the contents of which
|
|
|
|
* should not be saved during the suspend.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct nosave_region {
|
|
|
|
struct list_head list;
|
|
|
|
unsigned long start_pfn;
|
|
|
|
unsigned long end_pfn;
|
|
|
|
};
|
|
|
|
|
|
|
|
static LIST_HEAD(nosave_regions);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* register_nosave_region - register a range of page frames the contents
|
|
|
|
* of which should not be saved during the suspend (to be used in the early
|
|
|
|
* initialization code)
|
|
|
|
*/
|
|
|
|
|
|
|
|
void __init
|
2007-05-08 03:23:49 -06:00
|
|
|
__register_nosave_region(unsigned long start_pfn, unsigned long end_pfn,
|
|
|
|
int use_kmalloc)
|
2007-05-06 15:50:43 -06:00
|
|
|
{
|
|
|
|
struct nosave_region *region;
|
|
|
|
|
|
|
|
if (start_pfn >= end_pfn)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!list_empty(&nosave_regions)) {
|
|
|
|
/* Try to extend the previous region (they should be sorted) */
|
|
|
|
region = list_entry(nosave_regions.prev,
|
|
|
|
struct nosave_region, list);
|
|
|
|
if (region->end_pfn == start_pfn) {
|
|
|
|
region->end_pfn = end_pfn;
|
|
|
|
goto Report;
|
|
|
|
}
|
|
|
|
}
|
2007-05-08 03:23:49 -06:00
|
|
|
if (use_kmalloc) {
|
|
|
|
/* during init, this shouldn't fail */
|
|
|
|
region = kmalloc(sizeof(struct nosave_region), GFP_KERNEL);
|
|
|
|
BUG_ON(!region);
|
|
|
|
} else
|
|
|
|
/* This allocation cannot fail */
|
2009-09-21 18:03:06 -06:00
|
|
|
region = alloc_bootmem(sizeof(struct nosave_region));
|
2007-05-06 15:50:43 -06:00
|
|
|
region->start_pfn = start_pfn;
|
|
|
|
region->end_pfn = end_pfn;
|
|
|
|
list_add_tail(®ion->list, &nosave_regions);
|
|
|
|
Report:
|
2013-06-03 12:20:29 -06:00
|
|
|
printk(KERN_INFO "PM: Registered nosave memory: [mem %#010llx-%#010llx]\n",
|
|
|
|
(unsigned long long) start_pfn << PAGE_SHIFT,
|
|
|
|
((unsigned long long) end_pfn << PAGE_SHIFT) - 1);
|
2007-05-06 15:50:43 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set bits in this map correspond to the page frames the contents of which
|
|
|
|
* should not be saved during the suspend.
|
|
|
|
*/
|
|
|
|
static struct memory_bitmap *forbidden_pages_map;
|
|
|
|
|
|
|
|
/* Set bits in this map correspond to free page frames. */
|
|
|
|
static struct memory_bitmap *free_pages_map;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Each page frame allocated for creating the image is marked by setting the
|
|
|
|
* corresponding bits in forbidden_pages_map and free_pages_map simultaneously
|
|
|
|
*/
|
|
|
|
|
|
|
|
void swsusp_set_page_free(struct page *page)
|
|
|
|
{
|
|
|
|
if (free_pages_map)
|
|
|
|
memory_bm_set_bit(free_pages_map, page_to_pfn(page));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int swsusp_page_is_free(struct page *page)
|
|
|
|
{
|
|
|
|
return free_pages_map ?
|
|
|
|
memory_bm_test_bit(free_pages_map, page_to_pfn(page)) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void swsusp_unset_page_free(struct page *page)
|
|
|
|
{
|
|
|
|
if (free_pages_map)
|
|
|
|
memory_bm_clear_bit(free_pages_map, page_to_pfn(page));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void swsusp_set_page_forbidden(struct page *page)
|
|
|
|
{
|
|
|
|
if (forbidden_pages_map)
|
|
|
|
memory_bm_set_bit(forbidden_pages_map, page_to_pfn(page));
|
|
|
|
}
|
|
|
|
|
|
|
|
int swsusp_page_is_forbidden(struct page *page)
|
|
|
|
{
|
|
|
|
return forbidden_pages_map ?
|
|
|
|
memory_bm_test_bit(forbidden_pages_map, page_to_pfn(page)) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void swsusp_unset_page_forbidden(struct page *page)
|
|
|
|
{
|
|
|
|
if (forbidden_pages_map)
|
|
|
|
memory_bm_clear_bit(forbidden_pages_map, page_to_pfn(page));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mark_nosave_pages - set bits corresponding to the page frames the
|
|
|
|
* contents of which should not be saved in a given bitmap.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void mark_nosave_pages(struct memory_bitmap *bm)
|
|
|
|
{
|
|
|
|
struct nosave_region *region;
|
|
|
|
|
|
|
|
if (list_empty(&nosave_regions))
|
|
|
|
return;
|
|
|
|
|
|
|
|
list_for_each_entry(region, &nosave_regions, list) {
|
|
|
|
unsigned long pfn;
|
|
|
|
|
2012-02-14 14:20:52 -07:00
|
|
|
pr_debug("PM: Marking nosave pages: [mem %#010llx-%#010llx]\n",
|
|
|
|
(unsigned long long) region->start_pfn << PAGE_SHIFT,
|
|
|
|
((unsigned long long) region->end_pfn << PAGE_SHIFT)
|
|
|
|
- 1);
|
2007-05-06 15:50:43 -06:00
|
|
|
|
|
|
|
for (pfn = region->start_pfn; pfn < region->end_pfn; pfn++)
|
2008-03-11 17:34:57 -06:00
|
|
|
if (pfn_valid(pfn)) {
|
|
|
|
/*
|
|
|
|
* It is safe to ignore the result of
|
|
|
|
* mem_bm_set_bit_check() here, since we won't
|
|
|
|
* touch the PFNs for which the error is
|
|
|
|
* returned anyway.
|
|
|
|
*/
|
|
|
|
mem_bm_set_bit_check(bm, pfn);
|
|
|
|
}
|
2007-05-06 15:50:43 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* create_basic_memory_bitmaps - create bitmaps needed for marking page
|
|
|
|
* frames that should not be saved and free page frames. The pointers
|
|
|
|
* forbidden_pages_map and free_pages_map are only modified if everything
|
|
|
|
* goes well, because we don't want the bits to be used before both bitmaps
|
|
|
|
* are set up.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int create_basic_memory_bitmaps(void)
|
|
|
|
{
|
|
|
|
struct memory_bitmap *bm1, *bm2;
|
|
|
|
int error = 0;
|
|
|
|
|
2013-09-30 11:40:56 -06:00
|
|
|
if (forbidden_pages_map && free_pages_map)
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
BUG_ON(forbidden_pages_map || free_pages_map);
|
2007-05-06 15:50:43 -06:00
|
|
|
|
2007-05-06 15:50:45 -06:00
|
|
|
bm1 = kzalloc(sizeof(struct memory_bitmap), GFP_KERNEL);
|
2007-05-06 15:50:43 -06:00
|
|
|
if (!bm1)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-05-06 15:50:45 -06:00
|
|
|
error = memory_bm_create(bm1, GFP_KERNEL, PG_ANY);
|
2007-05-06 15:50:43 -06:00
|
|
|
if (error)
|
|
|
|
goto Free_first_object;
|
|
|
|
|
2007-05-06 15:50:45 -06:00
|
|
|
bm2 = kzalloc(sizeof(struct memory_bitmap), GFP_KERNEL);
|
2007-05-06 15:50:43 -06:00
|
|
|
if (!bm2)
|
|
|
|
goto Free_first_bitmap;
|
|
|
|
|
2007-05-06 15:50:45 -06:00
|
|
|
error = memory_bm_create(bm2, GFP_KERNEL, PG_ANY);
|
2007-05-06 15:50:43 -06:00
|
|
|
if (error)
|
|
|
|
goto Free_second_object;
|
|
|
|
|
|
|
|
forbidden_pages_map = bm1;
|
|
|
|
free_pages_map = bm2;
|
|
|
|
mark_nosave_pages(forbidden_pages_map);
|
|
|
|
|
2007-12-07 18:09:43 -07:00
|
|
|
pr_debug("PM: Basic memory bitmaps created\n");
|
2007-05-06 15:50:43 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
Free_second_object:
|
|
|
|
kfree(bm2);
|
|
|
|
Free_first_bitmap:
|
|
|
|
memory_bm_free(bm1, PG_UNSAFE_CLEAR);
|
|
|
|
Free_first_object:
|
|
|
|
kfree(bm1);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* free_basic_memory_bitmaps - free memory bitmaps allocated by
|
|
|
|
* create_basic_memory_bitmaps(). The auxiliary pointers are necessary
|
|
|
|
* so that the bitmaps themselves are not referred to while they are being
|
|
|
|
* freed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void free_basic_memory_bitmaps(void)
|
|
|
|
{
|
|
|
|
struct memory_bitmap *bm1, *bm2;
|
|
|
|
|
2013-11-14 15:26:58 -07:00
|
|
|
if (WARN_ON(!(forbidden_pages_map && free_pages_map)))
|
|
|
|
return;
|
2007-05-06 15:50:43 -06:00
|
|
|
|
|
|
|
bm1 = forbidden_pages_map;
|
|
|
|
bm2 = free_pages_map;
|
|
|
|
forbidden_pages_map = NULL;
|
|
|
|
free_pages_map = NULL;
|
|
|
|
memory_bm_free(bm1, PG_UNSAFE_CLEAR);
|
|
|
|
kfree(bm1);
|
|
|
|
memory_bm_free(bm2, PG_UNSAFE_CLEAR);
|
|
|
|
kfree(bm2);
|
|
|
|
|
2007-12-07 18:09:43 -07:00
|
|
|
pr_debug("PM: Basic memory bitmaps freed\n");
|
2007-05-06 15:50:43 -06:00
|
|
|
}
|
|
|
|
|
2006-09-26 00:32:54 -06:00
|
|
|
/**
|
|
|
|
* snapshot_additional_pages - estimate the number of additional pages
|
|
|
|
* be needed for setting up the suspend image data structures for given
|
|
|
|
* zone (usually the returned value is greater than the exact number)
|
|
|
|
*/
|
|
|
|
|
|
|
|
unsigned int snapshot_additional_pages(struct zone *zone)
|
|
|
|
{
|
|
|
|
unsigned int res;
|
|
|
|
|
|
|
|
res = DIV_ROUND_UP(zone->spanned_pages, BM_BITS_PER_BLOCK);
|
2012-01-19 15:23:10 -07:00
|
|
|
res += DIV_ROUND_UP(res * sizeof(struct bm_block),
|
|
|
|
LINKED_PAGE_DATA_SIZE);
|
[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-06 21:34:18 -07:00
|
|
|
return 2 * res;
|
2006-09-26 00:32:54 -06:00
|
|
|
}
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
/**
|
|
|
|
* count_free_highmem_pages - compute the total number of free highmem
|
|
|
|
* pages, system-wide.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int count_free_highmem_pages(void)
|
|
|
|
{
|
|
|
|
struct zone *zone;
|
|
|
|
unsigned int cnt = 0;
|
|
|
|
|
2009-03-31 16:19:31 -06:00
|
|
|
for_each_populated_zone(zone)
|
|
|
|
if (is_highmem(zone))
|
2007-02-10 02:43:02 -07:00
|
|
|
cnt += zone_page_state(zone, NR_FREE_PAGES);
|
[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-06 21:34:18 -07:00
|
|
|
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* saveable_highmem_page - Determine whether a highmem page should be
|
|
|
|
* included in the suspend image.
|
|
|
|
*
|
|
|
|
* We should save the page if it isn't Nosave or NosaveFree, or Reserved,
|
|
|
|
* and it isn't a part of a free chunk of pages.
|
|
|
|
*/
|
2008-11-26 16:00:24 -07:00
|
|
|
static struct page *saveable_highmem_page(struct zone *zone, unsigned long pfn)
|
[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-06 21:34:18 -07:00
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
if (!pfn_valid(pfn))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
page = pfn_to_page(pfn);
|
2008-11-26 16:00:24 -07:00
|
|
|
if (page_zone(page) != zone)
|
|
|
|
return NULL;
|
[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-06 21:34:18 -07:00
|
|
|
|
|
|
|
BUG_ON(!PageHighMem(page));
|
|
|
|
|
2007-05-06 15:50:42 -06:00
|
|
|
if (swsusp_page_is_forbidden(page) || swsusp_page_is_free(page) ||
|
|
|
|
PageReserved(page))
|
[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-06 21:34:18 -07:00
|
|
|
return NULL;
|
|
|
|
|
2012-01-10 16:07:31 -07:00
|
|
|
if (page_is_guard(page))
|
|
|
|
return NULL;
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* count_highmem_pages - compute the total number of saveable highmem
|
|
|
|
* pages.
|
|
|
|
*/
|
|
|
|
|
2009-06-11 15:11:17 -06:00
|
|
|
static unsigned int count_highmem_pages(void)
|
[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-06 21:34:18 -07:00
|
|
|
{
|
|
|
|
struct zone *zone;
|
|
|
|
unsigned int n = 0;
|
|
|
|
|
PM / Hibernate / Memory hotplug: Always use for_each_populated_zone()
Use for_each_populated_zone() instead of for_each_zone() in hibernation
code. This fixes a bug on s390, where we allow both config options
HIBERNATION and MEMORY_HOTPLUG, so that we also have a ZONE_MOVABLE
here. We only allow hibernation if no memory hotplug operation was
performed, so in fact both features can only be used exclusively, but
this way we don't need 2 differently configured (distribution) kernels.
If we have an unpopulated ZONE_MOVABLE, we allow hibernation but run
into a BUG_ON() in memory_bm_test/set/clear_bit() because hibernation
code iterates through all zones, not only the populated zones, in
several places. For example, swsusp_free() does for_each_zone() and
then checks for pfn_valid(), which is true even if the zone is not
populated, resulting in a BUG_ON() later because the pfn cannot be
found in the memory bitmap.
Replacing all occurences of for_each_zone() in hibernation code with
for_each_populated_zone() would fix this issue.
[rjw: Rebased on top of linux-next hibernation patches.]
Signed-off-by: Gerald Schaefer <gerald.schaefer@de.ibm.com>
Acked-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2009-07-21 16:36:56 -06:00
|
|
|
for_each_populated_zone(zone) {
|
[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-06 21:34:18 -07:00
|
|
|
unsigned long pfn, max_zone_pfn;
|
|
|
|
|
|
|
|
if (!is_highmem(zone))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
mark_free_pages(zone);
|
2013-09-11 15:21:44 -06:00
|
|
|
max_zone_pfn = zone_end_pfn(zone);
|
[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-06 21:34:18 -07:00
|
|
|
for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
|
2008-11-26 16:00:24 -07:00
|
|
|
if (saveable_highmem_page(zone, pfn))
|
[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-06 21:34:18 -07:00
|
|
|
n++;
|
|
|
|
}
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
#else
|
2008-11-26 16:00:24 -07:00
|
|
|
static inline void *saveable_highmem_page(struct zone *z, unsigned long p)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
[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-06 21:34:18 -07:00
|
|
|
#endif /* CONFIG_HIGHMEM */
|
|
|
|
|
2005-10-30 15:59:56 -07:00
|
|
|
/**
|
2008-02-19 17:47:44 -07:00
|
|
|
* saveable_page - Determine whether a non-highmem page should be included
|
|
|
|
* in the suspend image.
|
2005-10-30 15:59:56 -07:00
|
|
|
*
|
[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-06 21:34:18 -07:00
|
|
|
* We should save the page if it isn't Nosave, and is not in the range
|
|
|
|
* of pages statically defined as 'unsaveable', and it isn't a part of
|
|
|
|
* a free chunk of pages.
|
2005-10-30 15:59:56 -07:00
|
|
|
*/
|
2008-11-26 16:00:24 -07:00
|
|
|
static struct page *saveable_page(struct zone *zone, unsigned long pfn)
|
2005-10-30 15:59:56 -07:00
|
|
|
{
|
2005-10-30 15:59:59 -07:00
|
|
|
struct page *page;
|
2005-10-30 15:59:56 -07:00
|
|
|
|
|
|
|
if (!pfn_valid(pfn))
|
2006-09-26 00:32:45 -06:00
|
|
|
return NULL;
|
2005-10-30 15:59:56 -07:00
|
|
|
|
|
|
|
page = pfn_to_page(pfn);
|
2008-11-26 16:00:24 -07:00
|
|
|
if (page_zone(page) != zone)
|
|
|
|
return NULL;
|
2006-09-26 00:32:45 -06:00
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
BUG_ON(PageHighMem(page));
|
|
|
|
|
2007-05-06 15:50:42 -06:00
|
|
|
if (swsusp_page_is_forbidden(page) || swsusp_page_is_free(page))
|
2006-09-26 00:32:45 -06:00
|
|
|
return NULL;
|
[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-06 21:34:18 -07:00
|
|
|
|
2008-02-19 17:47:44 -07:00
|
|
|
if (PageReserved(page)
|
|
|
|
&& (!kernel_page_present(page) || pfn_is_nosave(pfn)))
|
2006-09-26 00:32:45 -06:00
|
|
|
return NULL;
|
2005-10-30 15:59:56 -07:00
|
|
|
|
2012-01-10 16:07:31 -07:00
|
|
|
if (page_is_guard(page))
|
|
|
|
return NULL;
|
|
|
|
|
2006-09-26 00:32:45 -06:00
|
|
|
return page;
|
2005-10-30 15:59:56 -07:00
|
|
|
}
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
/**
|
|
|
|
* count_data_pages - compute the total number of saveable non-highmem
|
|
|
|
* pages.
|
|
|
|
*/
|
|
|
|
|
2009-06-11 15:11:17 -06:00
|
|
|
static unsigned int count_data_pages(void)
|
2005-10-30 15:59:56 -07:00
|
|
|
{
|
|
|
|
struct zone *zone;
|
2006-09-26 00:32:45 -06:00
|
|
|
unsigned long pfn, max_zone_pfn;
|
2005-11-07 01:58:40 -07:00
|
|
|
unsigned int n = 0;
|
2005-10-30 15:59:56 -07:00
|
|
|
|
PM / Hibernate / Memory hotplug: Always use for_each_populated_zone()
Use for_each_populated_zone() instead of for_each_zone() in hibernation
code. This fixes a bug on s390, where we allow both config options
HIBERNATION and MEMORY_HOTPLUG, so that we also have a ZONE_MOVABLE
here. We only allow hibernation if no memory hotplug operation was
performed, so in fact both features can only be used exclusively, but
this way we don't need 2 differently configured (distribution) kernels.
If we have an unpopulated ZONE_MOVABLE, we allow hibernation but run
into a BUG_ON() in memory_bm_test/set/clear_bit() because hibernation
code iterates through all zones, not only the populated zones, in
several places. For example, swsusp_free() does for_each_zone() and
then checks for pfn_valid(), which is true even if the zone is not
populated, resulting in a BUG_ON() later because the pfn cannot be
found in the memory bitmap.
Replacing all occurences of for_each_zone() in hibernation code with
for_each_populated_zone() would fix this issue.
[rjw: Rebased on top of linux-next hibernation patches.]
Signed-off-by: Gerald Schaefer <gerald.schaefer@de.ibm.com>
Acked-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2009-07-21 16:36:56 -06:00
|
|
|
for_each_populated_zone(zone) {
|
2005-10-30 15:59:56 -07:00
|
|
|
if (is_highmem(zone))
|
|
|
|
continue;
|
[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-06 21:34:18 -07:00
|
|
|
|
2005-10-30 15:59:56 -07:00
|
|
|
mark_free_pages(zone);
|
2013-09-11 15:21:44 -06:00
|
|
|
max_zone_pfn = zone_end_pfn(zone);
|
2006-09-26 00:32:45 -06:00
|
|
|
for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
|
2008-11-26 16:00:24 -07:00
|
|
|
if (saveable_page(zone, pfn))
|
[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-06 21:34:18 -07:00
|
|
|
n++;
|
2005-10-30 15:59:56 -07:00
|
|
|
}
|
2005-10-30 15:59:57 -07:00
|
|
|
return n;
|
2005-10-30 15:59:56 -07:00
|
|
|
}
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
/* This is needed, because copy_page and memcpy are not usable for copying
|
|
|
|
* task structs.
|
|
|
|
*/
|
|
|
|
static inline void do_copy_page(long *dst, long *src)
|
2006-09-26 00:32:49 -06:00
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
for (n = PAGE_SIZE / sizeof(long); n; n--)
|
|
|
|
*dst++ = *src++;
|
|
|
|
}
|
|
|
|
|
2008-02-19 17:47:44 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* safe_copy_page - check if the page we are going to copy is marked as
|
|
|
|
* present in the kernel page tables (this always is the case if
|
|
|
|
* CONFIG_DEBUG_PAGEALLOC is not set and in that case
|
|
|
|
* kernel_page_present() always returns 'true').
|
|
|
|
*/
|
|
|
|
static void safe_copy_page(void *dst, struct page *s_page)
|
|
|
|
{
|
|
|
|
if (kernel_page_present(s_page)) {
|
|
|
|
do_copy_page(dst, page_address(s_page));
|
|
|
|
} else {
|
|
|
|
kernel_map_pages(s_page, 1, 1);
|
|
|
|
do_copy_page(dst, page_address(s_page));
|
|
|
|
kernel_map_pages(s_page, 1, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
static inline struct page *
|
|
|
|
page_is_saveable(struct zone *zone, unsigned long pfn)
|
|
|
|
{
|
|
|
|
return is_highmem(zone) ?
|
2008-11-26 16:00:24 -07:00
|
|
|
saveable_highmem_page(zone, pfn) : saveable_page(zone, pfn);
|
[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-06 21:34:18 -07:00
|
|
|
}
|
|
|
|
|
2008-02-19 17:47:44 -07:00
|
|
|
static void copy_data_page(unsigned long dst_pfn, unsigned long src_pfn)
|
[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-06 21:34:18 -07:00
|
|
|
{
|
|
|
|
struct page *s_page, *d_page;
|
|
|
|
void *src, *dst;
|
|
|
|
|
|
|
|
s_page = pfn_to_page(src_pfn);
|
|
|
|
d_page = pfn_to_page(dst_pfn);
|
|
|
|
if (PageHighMem(s_page)) {
|
2011-11-25 08:14:38 -07:00
|
|
|
src = kmap_atomic(s_page);
|
|
|
|
dst = kmap_atomic(d_page);
|
[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-06 21:34:18 -07:00
|
|
|
do_copy_page(dst, src);
|
2011-11-25 08:14:38 -07:00
|
|
|
kunmap_atomic(dst);
|
|
|
|
kunmap_atomic(src);
|
[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-06 21:34:18 -07:00
|
|
|
} else {
|
|
|
|
if (PageHighMem(d_page)) {
|
|
|
|
/* Page pointed to by src may contain some kernel
|
|
|
|
* data modified by kmap_atomic()
|
|
|
|
*/
|
2008-02-19 17:47:44 -07:00
|
|
|
safe_copy_page(buffer, s_page);
|
2011-11-25 08:14:38 -07:00
|
|
|
dst = kmap_atomic(d_page);
|
2010-10-26 15:22:27 -06:00
|
|
|
copy_page(dst, buffer);
|
2011-11-25 08:14:38 -07:00
|
|
|
kunmap_atomic(dst);
|
[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-06 21:34:18 -07:00
|
|
|
} else {
|
2008-02-19 17:47:44 -07:00
|
|
|
safe_copy_page(page_address(d_page), s_page);
|
[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-06 21:34:18 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
2008-11-26 16:00:24 -07:00
|
|
|
#define page_is_saveable(zone, pfn) saveable_page(zone, pfn)
|
[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-06 21:34:18 -07:00
|
|
|
|
2008-02-19 17:47:44 -07:00
|
|
|
static inline void copy_data_page(unsigned long dst_pfn, unsigned long src_pfn)
|
[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-06 21:34:18 -07:00
|
|
|
{
|
2008-02-19 17:47:44 -07:00
|
|
|
safe_copy_page(page_address(pfn_to_page(dst_pfn)),
|
|
|
|
pfn_to_page(src_pfn));
|
[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-06 21:34:18 -07:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_HIGHMEM */
|
|
|
|
|
2006-09-26 00:32:54 -06:00
|
|
|
static void
|
|
|
|
copy_data_pages(struct memory_bitmap *copy_bm, struct memory_bitmap *orig_bm)
|
2005-10-30 15:59:56 -07:00
|
|
|
{
|
|
|
|
struct zone *zone;
|
2006-09-26 00:32:54 -06:00
|
|
|
unsigned long pfn;
|
2005-10-30 15:59:56 -07:00
|
|
|
|
PM / Hibernate / Memory hotplug: Always use for_each_populated_zone()
Use for_each_populated_zone() instead of for_each_zone() in hibernation
code. This fixes a bug on s390, where we allow both config options
HIBERNATION and MEMORY_HOTPLUG, so that we also have a ZONE_MOVABLE
here. We only allow hibernation if no memory hotplug operation was
performed, so in fact both features can only be used exclusively, but
this way we don't need 2 differently configured (distribution) kernels.
If we have an unpopulated ZONE_MOVABLE, we allow hibernation but run
into a BUG_ON() in memory_bm_test/set/clear_bit() because hibernation
code iterates through all zones, not only the populated zones, in
several places. For example, swsusp_free() does for_each_zone() and
then checks for pfn_valid(), which is true even if the zone is not
populated, resulting in a BUG_ON() later because the pfn cannot be
found in the memory bitmap.
Replacing all occurences of for_each_zone() in hibernation code with
for_each_populated_zone() would fix this issue.
[rjw: Rebased on top of linux-next hibernation patches.]
Signed-off-by: Gerald Schaefer <gerald.schaefer@de.ibm.com>
Acked-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2009-07-21 16:36:56 -06:00
|
|
|
for_each_populated_zone(zone) {
|
2006-09-26 00:32:54 -06:00
|
|
|
unsigned long max_zone_pfn;
|
|
|
|
|
2005-10-30 15:59:56 -07:00
|
|
|
mark_free_pages(zone);
|
2013-09-11 15:21:44 -06:00
|
|
|
max_zone_pfn = zone_end_pfn(zone);
|
2006-09-26 00:32:54 -06:00
|
|
|
for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
|
[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-06 21:34:18 -07:00
|
|
|
if (page_is_saveable(zone, pfn))
|
2006-09-26 00:32:54 -06:00
|
|
|
memory_bm_set_bit(orig_bm, pfn);
|
2005-10-30 15:59:56 -07:00
|
|
|
}
|
2006-09-26 00:32:54 -06:00
|
|
|
memory_bm_position_reset(orig_bm);
|
|
|
|
memory_bm_position_reset(copy_bm);
|
2007-10-19 18:26:04 -06:00
|
|
|
for(;;) {
|
2006-09-26 00:32:54 -06:00
|
|
|
pfn = memory_bm_next_pfn(orig_bm);
|
2007-10-19 18:26:04 -06:00
|
|
|
if (unlikely(pfn == BM_END_OF_MAP))
|
|
|
|
break;
|
|
|
|
copy_data_page(memory_bm_next_pfn(copy_bm), pfn);
|
|
|
|
}
|
2005-10-30 15:59:56 -07:00
|
|
|
}
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
/* Total number of image pages */
|
|
|
|
static unsigned int nr_copy_pages;
|
|
|
|
/* Number of pages needed for saving the original pfns of the image pages */
|
|
|
|
static unsigned int nr_meta_pages;
|
2009-07-08 05:24:05 -06:00
|
|
|
/*
|
|
|
|
* Numbers of normal and highmem page frames allocated for hibernation image
|
|
|
|
* before suspending devices.
|
|
|
|
*/
|
|
|
|
unsigned int alloc_normal, alloc_highmem;
|
|
|
|
/*
|
|
|
|
* Memory bitmap used for marking saveable pages (during hibernation) or
|
|
|
|
* hibernation image pages (during restore)
|
|
|
|
*/
|
|
|
|
static struct memory_bitmap orig_bm;
|
|
|
|
/*
|
|
|
|
* Memory bitmap used during hibernation for marking allocated page frames that
|
|
|
|
* will contain copies of saveable pages. During restore it is initially used
|
|
|
|
* for marking hibernation image pages, but then the set bits from it are
|
|
|
|
* duplicated in @orig_bm and it is released. On highmem systems it is next
|
|
|
|
* used for marking "safe" highmem pages, but it has to be reinitialized for
|
|
|
|
* this purpose.
|
|
|
|
*/
|
|
|
|
static struct memory_bitmap copy_bm;
|
[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-06 21:34:18 -07:00
|
|
|
|
2005-10-30 15:59:56 -07:00
|
|
|
/**
|
[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 00:32:55 -06:00
|
|
|
* swsusp_free - free pages allocated for the suspend.
|
2006-09-26 00:32:50 -06:00
|
|
|
*
|
[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 00:32:55 -06:00
|
|
|
* Suspend pages are alocated before the atomic copy is made, so we
|
|
|
|
* need to release them after the resume.
|
2005-10-30 15:59:56 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
void swsusp_free(void)
|
|
|
|
{
|
|
|
|
struct zone *zone;
|
2006-09-26 00:32:45 -06:00
|
|
|
unsigned long pfn, max_zone_pfn;
|
2005-10-30 15:59:56 -07:00
|
|
|
|
PM / Hibernate / Memory hotplug: Always use for_each_populated_zone()
Use for_each_populated_zone() instead of for_each_zone() in hibernation
code. This fixes a bug on s390, where we allow both config options
HIBERNATION and MEMORY_HOTPLUG, so that we also have a ZONE_MOVABLE
here. We only allow hibernation if no memory hotplug operation was
performed, so in fact both features can only be used exclusively, but
this way we don't need 2 differently configured (distribution) kernels.
If we have an unpopulated ZONE_MOVABLE, we allow hibernation but run
into a BUG_ON() in memory_bm_test/set/clear_bit() because hibernation
code iterates through all zones, not only the populated zones, in
several places. For example, swsusp_free() does for_each_zone() and
then checks for pfn_valid(), which is true even if the zone is not
populated, resulting in a BUG_ON() later because the pfn cannot be
found in the memory bitmap.
Replacing all occurences of for_each_zone() in hibernation code with
for_each_populated_zone() would fix this issue.
[rjw: Rebased on top of linux-next hibernation patches.]
Signed-off-by: Gerald Schaefer <gerald.schaefer@de.ibm.com>
Acked-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2009-07-21 16:36:56 -06:00
|
|
|
for_each_populated_zone(zone) {
|
2013-09-11 15:21:44 -06:00
|
|
|
max_zone_pfn = zone_end_pfn(zone);
|
2006-09-26 00:32:45 -06:00
|
|
|
for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
|
|
|
|
if (pfn_valid(pfn)) {
|
|
|
|
struct page *page = pfn_to_page(pfn);
|
|
|
|
|
2007-05-06 15:50:42 -06:00
|
|
|
if (swsusp_page_is_forbidden(page) &&
|
|
|
|
swsusp_page_is_free(page)) {
|
|
|
|
swsusp_unset_page_forbidden(page);
|
|
|
|
swsusp_unset_page_free(page);
|
[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-06 21:34:18 -07:00
|
|
|
__free_page(page);
|
2005-10-30 15:59:56 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-03-23 03:59:59 -07:00
|
|
|
nr_copy_pages = 0;
|
|
|
|
nr_meta_pages = 0;
|
2006-09-26 00:32:52 -06:00
|
|
|
restore_pblist = NULL;
|
2006-03-23 04:00:03 -07:00
|
|
|
buffer = NULL;
|
2009-07-08 05:24:05 -06:00
|
|
|
alloc_normal = 0;
|
|
|
|
alloc_highmem = 0;
|
2005-10-30 15:59:56 -07:00
|
|
|
}
|
|
|
|
|
2009-07-08 05:23:51 -06:00
|
|
|
/* Helper functions used for the shrinking of memory. */
|
|
|
|
|
|
|
|
#define GFP_IMAGE (GFP_KERNEL | __GFP_NOWARN)
|
|
|
|
|
2009-06-11 15:11:17 -06:00
|
|
|
/**
|
2009-07-08 05:23:51 -06:00
|
|
|
* preallocate_image_pages - Allocate a number of pages for hibernation image
|
|
|
|
* @nr_pages: Number of page frames to allocate.
|
|
|
|
* @mask: GFP flags to use for the allocation.
|
2009-06-11 15:11:17 -06:00
|
|
|
*
|
2009-07-08 05:23:51 -06:00
|
|
|
* Return value: Number of page frames actually allocated
|
|
|
|
*/
|
|
|
|
static unsigned long preallocate_image_pages(unsigned long nr_pages, gfp_t mask)
|
|
|
|
{
|
|
|
|
unsigned long nr_alloc = 0;
|
|
|
|
|
|
|
|
while (nr_pages > 0) {
|
2009-07-08 05:24:05 -06:00
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = alloc_image_page(mask);
|
|
|
|
if (!page)
|
2009-07-08 05:23:51 -06:00
|
|
|
break;
|
2009-07-08 05:24:05 -06:00
|
|
|
memory_bm_set_bit(©_bm, page_to_pfn(page));
|
|
|
|
if (PageHighMem(page))
|
|
|
|
alloc_highmem++;
|
|
|
|
else
|
|
|
|
alloc_normal++;
|
2009-07-08 05:23:51 -06:00
|
|
|
nr_pages--;
|
|
|
|
nr_alloc++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return nr_alloc;
|
|
|
|
}
|
|
|
|
|
2010-09-11 12:58:27 -06:00
|
|
|
static unsigned long preallocate_image_memory(unsigned long nr_pages,
|
|
|
|
unsigned long avail_normal)
|
2009-07-08 05:23:51 -06:00
|
|
|
{
|
2010-09-11 12:58:27 -06:00
|
|
|
unsigned long alloc;
|
|
|
|
|
|
|
|
if (avail_normal <= alloc_normal)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
alloc = avail_normal - alloc_normal;
|
|
|
|
if (nr_pages < alloc)
|
|
|
|
alloc = nr_pages;
|
|
|
|
|
|
|
|
return preallocate_image_pages(alloc, GFP_IMAGE);
|
2009-07-08 05:23:51 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
static unsigned long preallocate_image_highmem(unsigned long nr_pages)
|
|
|
|
{
|
|
|
|
return preallocate_image_pages(nr_pages, GFP_IMAGE | __GFP_HIGHMEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __fraction - Compute (an approximation of) x * (multiplier / base)
|
2009-06-11 15:11:17 -06:00
|
|
|
*/
|
2009-07-08 05:23:51 -06:00
|
|
|
static unsigned long __fraction(u64 x, u64 multiplier, u64 base)
|
|
|
|
{
|
|
|
|
x *= multiplier;
|
|
|
|
do_div(x, base);
|
|
|
|
return (unsigned long)x;
|
|
|
|
}
|
2009-06-11 15:11:17 -06:00
|
|
|
|
2009-07-08 05:23:51 -06:00
|
|
|
static unsigned long preallocate_highmem_fraction(unsigned long nr_pages,
|
|
|
|
unsigned long highmem,
|
|
|
|
unsigned long total)
|
2009-06-11 15:11:17 -06:00
|
|
|
{
|
2009-07-08 05:23:51 -06:00
|
|
|
unsigned long alloc = __fraction(nr_pages, highmem, total);
|
|
|
|
|
|
|
|
return preallocate_image_pages(alloc, GFP_IMAGE | __GFP_HIGHMEM);
|
2009-06-11 15:11:17 -06:00
|
|
|
}
|
2009-07-08 05:23:51 -06:00
|
|
|
#else /* CONFIG_HIGHMEM */
|
|
|
|
static inline unsigned long preallocate_image_highmem(unsigned long nr_pages)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long preallocate_highmem_fraction(unsigned long nr_pages,
|
|
|
|
unsigned long highmem,
|
|
|
|
unsigned long total)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_HIGHMEM */
|
2009-06-11 15:11:17 -06:00
|
|
|
|
2009-07-08 05:23:51 -06:00
|
|
|
/**
|
2009-07-08 05:24:05 -06:00
|
|
|
* free_unnecessary_pages - Release preallocated pages not needed for the image
|
|
|
|
*/
|
|
|
|
static void free_unnecessary_pages(void)
|
|
|
|
{
|
2010-09-11 12:58:27 -06:00
|
|
|
unsigned long save, to_free_normal, to_free_highmem;
|
2009-07-08 05:24:05 -06:00
|
|
|
|
2010-09-11 12:58:27 -06:00
|
|
|
save = count_data_pages();
|
|
|
|
if (alloc_normal >= save) {
|
|
|
|
to_free_normal = alloc_normal - save;
|
|
|
|
save = 0;
|
|
|
|
} else {
|
|
|
|
to_free_normal = 0;
|
|
|
|
save -= alloc_normal;
|
|
|
|
}
|
|
|
|
save += count_highmem_pages();
|
|
|
|
if (alloc_highmem >= save) {
|
|
|
|
to_free_highmem = alloc_highmem - save;
|
2009-07-08 05:24:05 -06:00
|
|
|
} else {
|
|
|
|
to_free_highmem = 0;
|
2011-07-06 12:15:23 -06:00
|
|
|
save -= alloc_highmem;
|
|
|
|
if (to_free_normal > save)
|
|
|
|
to_free_normal -= save;
|
|
|
|
else
|
|
|
|
to_free_normal = 0;
|
2009-07-08 05:24:05 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
memory_bm_position_reset(©_bm);
|
|
|
|
|
2010-02-25 14:32:37 -07:00
|
|
|
while (to_free_normal > 0 || to_free_highmem > 0) {
|
2009-07-08 05:24:05 -06:00
|
|
|
unsigned long pfn = memory_bm_next_pfn(©_bm);
|
|
|
|
struct page *page = pfn_to_page(pfn);
|
|
|
|
|
|
|
|
if (PageHighMem(page)) {
|
|
|
|
if (!to_free_highmem)
|
|
|
|
continue;
|
|
|
|
to_free_highmem--;
|
|
|
|
alloc_highmem--;
|
|
|
|
} else {
|
|
|
|
if (!to_free_normal)
|
|
|
|
continue;
|
|
|
|
to_free_normal--;
|
|
|
|
alloc_normal--;
|
|
|
|
}
|
|
|
|
memory_bm_clear_bit(©_bm, pfn);
|
|
|
|
swsusp_unset_page_forbidden(page);
|
|
|
|
swsusp_unset_page_free(page);
|
|
|
|
__free_page(page);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-08 05:24:12 -06:00
|
|
|
/**
|
|
|
|
* minimum_image_size - Estimate the minimum acceptable size of an image
|
|
|
|
* @saveable: Number of saveable pages in the system.
|
|
|
|
*
|
|
|
|
* We want to avoid attempting to free too much memory too hard, so estimate the
|
|
|
|
* minimum acceptable size of a hibernation image to use as the lower limit for
|
|
|
|
* preallocating memory.
|
|
|
|
*
|
|
|
|
* We assume that the minimum image size should be proportional to
|
|
|
|
*
|
|
|
|
* [number of saveable pages] - [number of pages that can be freed in theory]
|
|
|
|
*
|
|
|
|
* where the second term is the sum of (1) reclaimable slab pages, (2) active
|
|
|
|
* and (3) inactive anonymouns pages, (4) active and (5) inactive file pages,
|
|
|
|
* minus mapped file pages.
|
|
|
|
*/
|
|
|
|
static unsigned long minimum_image_size(unsigned long saveable)
|
|
|
|
{
|
|
|
|
unsigned long size;
|
|
|
|
|
|
|
|
size = global_page_state(NR_SLAB_RECLAIMABLE)
|
|
|
|
+ global_page_state(NR_ACTIVE_ANON)
|
|
|
|
+ global_page_state(NR_INACTIVE_ANON)
|
|
|
|
+ global_page_state(NR_ACTIVE_FILE)
|
|
|
|
+ global_page_state(NR_INACTIVE_FILE)
|
|
|
|
- global_page_state(NR_FILE_MAPPED);
|
|
|
|
|
|
|
|
return saveable <= size ? 0 : saveable - size;
|
|
|
|
}
|
|
|
|
|
2009-07-08 05:24:05 -06:00
|
|
|
/**
|
|
|
|
* hibernate_preallocate_memory - Preallocate memory for hibernation image
|
2009-07-08 05:23:51 -06:00
|
|
|
*
|
|
|
|
* To create a hibernation image it is necessary to make a copy of every page
|
|
|
|
* frame in use. We also need a number of page frames to be free during
|
|
|
|
* hibernation for allocations made while saving the image and for device
|
|
|
|
* drivers, in case they need to allocate memory from their hibernation
|
2011-05-15 03:38:48 -06:00
|
|
|
* callbacks (these two numbers are given by PAGES_FOR_IO (which is a rough
|
|
|
|
* estimate) and reserverd_size divided by PAGE_SIZE (which is tunable through
|
|
|
|
* /sys/power/reserved_size, respectively). To make this happen, we compute the
|
|
|
|
* total number of available page frames and allocate at least
|
2009-07-08 05:23:51 -06:00
|
|
|
*
|
2011-05-15 03:38:48 -06:00
|
|
|
* ([page frames total] + PAGES_FOR_IO + [metadata pages]) / 2
|
|
|
|
* + 2 * DIV_ROUND_UP(reserved_size, PAGE_SIZE)
|
2009-07-08 05:23:51 -06:00
|
|
|
*
|
|
|
|
* of them, which corresponds to the maximum size of a hibernation image.
|
|
|
|
*
|
|
|
|
* If image_size is set below the number following from the above formula,
|
|
|
|
* the preallocation of memory is continued until the total number of saveable
|
2009-07-08 05:24:12 -06:00
|
|
|
* pages in the system is below the requested image size or the minimum
|
|
|
|
* acceptable image size returned by minimum_image_size(), whichever is greater.
|
2009-07-08 05:23:51 -06:00
|
|
|
*/
|
2009-07-08 05:24:05 -06:00
|
|
|
int hibernate_preallocate_memory(void)
|
2009-06-11 15:11:17 -06:00
|
|
|
{
|
|
|
|
struct zone *zone;
|
2009-07-08 05:23:51 -06:00
|
|
|
unsigned long saveable, size, max_size, count, highmem, pages = 0;
|
2010-09-11 12:58:27 -06:00
|
|
|
unsigned long alloc, save_highmem, pages_highmem, avail_normal;
|
2009-06-11 15:11:17 -06:00
|
|
|
struct timeval start, stop;
|
2009-07-08 05:24:05 -06:00
|
|
|
int error;
|
2009-06-11 15:11:17 -06:00
|
|
|
|
2009-07-08 05:24:05 -06:00
|
|
|
printk(KERN_INFO "PM: Preallocating image memory... ");
|
2009-06-11 15:11:17 -06:00
|
|
|
do_gettimeofday(&start);
|
|
|
|
|
2009-07-08 05:24:05 -06:00
|
|
|
error = memory_bm_create(&orig_bm, GFP_IMAGE, PG_ANY);
|
|
|
|
if (error)
|
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
error = memory_bm_create(©_bm, GFP_IMAGE, PG_ANY);
|
|
|
|
if (error)
|
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
alloc_normal = 0;
|
|
|
|
alloc_highmem = 0;
|
|
|
|
|
2009-07-08 05:23:51 -06:00
|
|
|
/* Count the number of saveable data pages. */
|
2009-07-08 05:24:05 -06:00
|
|
|
save_highmem = count_highmem_pages();
|
2009-07-08 05:23:51 -06:00
|
|
|
saveable = count_data_pages();
|
2009-06-11 15:11:17 -06:00
|
|
|
|
2009-07-08 05:23:51 -06:00
|
|
|
/*
|
|
|
|
* Compute the total number of page frames we can use (count) and the
|
|
|
|
* number of pages needed for image metadata (size).
|
|
|
|
*/
|
|
|
|
count = saveable;
|
2009-07-08 05:24:05 -06:00
|
|
|
saveable += save_highmem;
|
|
|
|
highmem = save_highmem;
|
2009-07-08 05:23:51 -06:00
|
|
|
size = 0;
|
|
|
|
for_each_populated_zone(zone) {
|
|
|
|
size += snapshot_additional_pages(zone);
|
|
|
|
if (is_highmem(zone))
|
|
|
|
highmem += zone_page_state(zone, NR_FREE_PAGES);
|
|
|
|
else
|
|
|
|
count += zone_page_state(zone, NR_FREE_PAGES);
|
|
|
|
}
|
2010-09-11 12:58:27 -06:00
|
|
|
avail_normal = count;
|
2009-07-08 05:23:51 -06:00
|
|
|
count += highmem;
|
|
|
|
count -= totalreserve_pages;
|
|
|
|
|
2011-08-17 12:42:24 -06:00
|
|
|
/* Add number of pages required for page keys (s390 only). */
|
|
|
|
size += page_key_additional_pages(saveable);
|
|
|
|
|
2009-07-08 05:23:51 -06:00
|
|
|
/* Compute the maximum number of saveable pages to leave in memory. */
|
2011-05-15 03:38:48 -06:00
|
|
|
max_size = (count - (size + PAGES_FOR_IO)) / 2
|
|
|
|
- 2 * DIV_ROUND_UP(reserved_size, PAGE_SIZE);
|
2010-09-20 11:44:38 -06:00
|
|
|
/* Compute the desired number of image pages specified by image_size. */
|
2009-07-08 05:23:51 -06:00
|
|
|
size = DIV_ROUND_UP(image_size, PAGE_SIZE);
|
|
|
|
if (size > max_size)
|
|
|
|
size = max_size;
|
|
|
|
/*
|
2010-09-20 11:44:38 -06:00
|
|
|
* If the desired number of image pages is at least as large as the
|
|
|
|
* current number of saveable pages in memory, allocate page frames for
|
|
|
|
* the image and we're done.
|
2009-07-08 05:23:51 -06:00
|
|
|
*/
|
2009-07-08 05:24:05 -06:00
|
|
|
if (size >= saveable) {
|
|
|
|
pages = preallocate_image_highmem(save_highmem);
|
2010-09-11 12:58:27 -06:00
|
|
|
pages += preallocate_image_memory(saveable - pages, avail_normal);
|
2009-07-08 05:23:51 -06:00
|
|
|
goto out;
|
2009-07-08 05:24:05 -06:00
|
|
|
}
|
2009-07-08 05:23:51 -06:00
|
|
|
|
2009-07-08 05:24:12 -06:00
|
|
|
/* Estimate the minimum size of the image. */
|
|
|
|
pages = minimum_image_size(saveable);
|
2010-09-11 12:58:27 -06:00
|
|
|
/*
|
|
|
|
* To avoid excessive pressure on the normal zone, leave room in it to
|
|
|
|
* accommodate an image of the minimum size (unless it's already too
|
|
|
|
* small, in which case don't preallocate pages from it at all).
|
|
|
|
*/
|
|
|
|
if (avail_normal > pages)
|
|
|
|
avail_normal -= pages;
|
|
|
|
else
|
|
|
|
avail_normal = 0;
|
2009-07-08 05:24:12 -06:00
|
|
|
if (size < pages)
|
|
|
|
size = min_t(unsigned long, pages, max_size);
|
|
|
|
|
2009-07-08 05:23:51 -06:00
|
|
|
/*
|
|
|
|
* Let the memory management subsystem know that we're going to need a
|
|
|
|
* large number of page frames to allocate and make it free some memory.
|
|
|
|
* NOTE: If this is not done, performance will be hurt badly in some
|
|
|
|
* test cases.
|
|
|
|
*/
|
|
|
|
shrink_all_memory(saveable - size);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The number of saveable pages in memory was too high, so apply some
|
|
|
|
* pressure to decrease it. First, make room for the largest possible
|
|
|
|
* image and fail if that doesn't work. Next, try to decrease the size
|
2009-07-08 05:24:12 -06:00
|
|
|
* of the image as much as indicated by 'size' using allocations from
|
|
|
|
* highmem and non-highmem zones separately.
|
2009-07-08 05:23:51 -06:00
|
|
|
*/
|
|
|
|
pages_highmem = preallocate_image_highmem(highmem / 2);
|
2013-11-05 17:41:31 -07:00
|
|
|
alloc = count - max_size;
|
|
|
|
if (alloc > pages_highmem)
|
|
|
|
alloc -= pages_highmem;
|
|
|
|
else
|
|
|
|
alloc = 0;
|
2010-09-11 12:58:27 -06:00
|
|
|
pages = preallocate_image_memory(alloc, avail_normal);
|
|
|
|
if (pages < alloc) {
|
|
|
|
/* We have exhausted non-highmem pages, try highmem. */
|
|
|
|
alloc -= pages;
|
|
|
|
pages += pages_highmem;
|
|
|
|
pages_highmem = preallocate_image_highmem(alloc);
|
|
|
|
if (pages_highmem < alloc)
|
|
|
|
goto err_out;
|
|
|
|
pages += pages_highmem;
|
|
|
|
/*
|
|
|
|
* size is the desired number of saveable pages to leave in
|
|
|
|
* memory, so try to preallocate (all memory - size) pages.
|
|
|
|
*/
|
|
|
|
alloc = (count - pages) - size;
|
|
|
|
pages += preallocate_image_highmem(alloc);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* There are approximately max_size saveable pages at this point
|
|
|
|
* and we want to reduce this number down to size.
|
|
|
|
*/
|
|
|
|
alloc = max_size - size;
|
|
|
|
size = preallocate_highmem_fraction(alloc, highmem, count);
|
|
|
|
pages_highmem += size;
|
|
|
|
alloc -= size;
|
|
|
|
size = preallocate_image_memory(alloc, avail_normal);
|
|
|
|
pages_highmem += preallocate_image_highmem(alloc - size);
|
|
|
|
pages += pages_highmem + size;
|
|
|
|
}
|
2009-07-08 05:23:51 -06:00
|
|
|
|
2009-07-08 05:24:05 -06:00
|
|
|
/*
|
|
|
|
* We only need as many page frames for the image as there are saveable
|
|
|
|
* pages in memory, but we have allocated more. Release the excessive
|
|
|
|
* ones now.
|
|
|
|
*/
|
|
|
|
free_unnecessary_pages();
|
2009-07-08 05:23:51 -06:00
|
|
|
|
|
|
|
out:
|
2009-06-11 15:11:17 -06:00
|
|
|
do_gettimeofday(&stop);
|
2009-07-08 05:24:05 -06:00
|
|
|
printk(KERN_CONT "done (allocated %lu pages)\n", pages);
|
|
|
|
swsusp_show_speed(&start, &stop, pages, "Allocated");
|
2009-06-11 15:11:17 -06:00
|
|
|
|
|
|
|
return 0;
|
2009-07-08 05:24:05 -06:00
|
|
|
|
|
|
|
err_out:
|
|
|
|
printk(KERN_CONT "\n");
|
|
|
|
swsusp_free();
|
|
|
|
return -ENOMEM;
|
2009-06-11 15:11:17 -06:00
|
|
|
}
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
/**
|
|
|
|
* count_pages_for_highmem - compute the number of non-highmem pages
|
|
|
|
* that will be necessary for creating copies of highmem pages.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int count_pages_for_highmem(unsigned int nr_highmem)
|
|
|
|
{
|
2009-07-08 05:24:05 -06:00
|
|
|
unsigned int free_highmem = count_free_highmem_pages() + alloc_highmem;
|
[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-06 21:34:18 -07:00
|
|
|
|
|
|
|
if (free_highmem >= nr_highmem)
|
|
|
|
nr_highmem = 0;
|
|
|
|
else
|
|
|
|
nr_highmem -= free_highmem;
|
|
|
|
|
|
|
|
return nr_highmem;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static unsigned int
|
|
|
|
count_pages_for_highmem(unsigned int nr_highmem) { return 0; }
|
|
|
|
#endif /* CONFIG_HIGHMEM */
|
2005-10-30 15:59:56 -07:00
|
|
|
|
|
|
|
/**
|
[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-06 21:34:18 -07:00
|
|
|
* enough_free_mem - Make sure we have enough free memory for the
|
|
|
|
* snapshot image.
|
2005-10-30 15:59:56 -07:00
|
|
|
*/
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
static int enough_free_mem(unsigned int nr_pages, unsigned int nr_highmem)
|
2005-10-30 15:59:56 -07:00
|
|
|
{
|
2006-01-06 01:14:20 -07:00
|
|
|
struct zone *zone;
|
2009-07-08 05:24:05 -06:00
|
|
|
unsigned int free = alloc_normal;
|
2006-01-06 01:14:20 -07:00
|
|
|
|
PM / Hibernate / Memory hotplug: Always use for_each_populated_zone()
Use for_each_populated_zone() instead of for_each_zone() in hibernation
code. This fixes a bug on s390, where we allow both config options
HIBERNATION and MEMORY_HOTPLUG, so that we also have a ZONE_MOVABLE
here. We only allow hibernation if no memory hotplug operation was
performed, so in fact both features can only be used exclusively, but
this way we don't need 2 differently configured (distribution) kernels.
If we have an unpopulated ZONE_MOVABLE, we allow hibernation but run
into a BUG_ON() in memory_bm_test/set/clear_bit() because hibernation
code iterates through all zones, not only the populated zones, in
several places. For example, swsusp_free() does for_each_zone() and
then checks for pfn_valid(), which is true even if the zone is not
populated, resulting in a BUG_ON() later because the pfn cannot be
found in the memory bitmap.
Replacing all occurences of for_each_zone() in hibernation code with
for_each_populated_zone() would fix this issue.
[rjw: Rebased on top of linux-next hibernation patches.]
Signed-off-by: Gerald Schaefer <gerald.schaefer@de.ibm.com>
Acked-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2009-07-21 16:36:56 -06:00
|
|
|
for_each_populated_zone(zone)
|
[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-06 21:34:18 -07:00
|
|
|
if (!is_highmem(zone))
|
2007-02-10 02:43:02 -07:00
|
|
|
free += zone_page_state(zone, NR_FREE_PAGES);
|
[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 00:32:55 -06:00
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
nr_pages += count_pages_for_highmem(nr_highmem);
|
2009-07-08 05:24:05 -06:00
|
|
|
pr_debug("PM: Normal pages needed: %u + %u, available pages: %u\n",
|
|
|
|
nr_pages, PAGES_FOR_IO, free);
|
[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 00:32:55 -06:00
|
|
|
|
2009-07-08 05:24:05 -06:00
|
|
|
return free > nr_pages + PAGES_FOR_IO;
|
2005-10-30 15:59:56 -07:00
|
|
|
}
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
/**
|
|
|
|
* get_highmem_buffer - if there are some highmem pages in the suspend
|
|
|
|
* image, we may need the buffer to copy them and/or load their data.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline int get_highmem_buffer(int safe_needed)
|
|
|
|
{
|
|
|
|
buffer = get_image_page(GFP_ATOMIC | __GFP_COLD, safe_needed);
|
|
|
|
return buffer ? 0 : -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* alloc_highmem_image_pages - allocate some highmem pages for the image.
|
|
|
|
* Try to allocate as many pages as needed, but if the number of free
|
|
|
|
* highmem pages is lesser than that, allocate them all.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline unsigned int
|
2009-07-08 05:24:05 -06:00
|
|
|
alloc_highmem_pages(struct memory_bitmap *bm, unsigned int nr_highmem)
|
[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-06 21:34:18 -07:00
|
|
|
{
|
|
|
|
unsigned int to_alloc = count_free_highmem_pages();
|
|
|
|
|
|
|
|
if (to_alloc > nr_highmem)
|
|
|
|
to_alloc = nr_highmem;
|
|
|
|
|
|
|
|
nr_highmem -= to_alloc;
|
|
|
|
while (to_alloc-- > 0) {
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = alloc_image_page(__GFP_HIGHMEM);
|
|
|
|
memory_bm_set_bit(bm, page_to_pfn(page));
|
|
|
|
}
|
|
|
|
return nr_highmem;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline int get_highmem_buffer(int safe_needed) { return 0; }
|
|
|
|
|
|
|
|
static inline unsigned int
|
2009-07-08 05:24:05 -06:00
|
|
|
alloc_highmem_pages(struct memory_bitmap *bm, unsigned int n) { return 0; }
|
[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-06 21:34:18 -07:00
|
|
|
#endif /* CONFIG_HIGHMEM */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* swsusp_alloc - allocate memory for the suspend image
|
|
|
|
*
|
|
|
|
* We first try to allocate as many highmem pages as there are
|
|
|
|
* saveable highmem pages in the system. If that fails, we allocate
|
|
|
|
* non-highmem pages for the copies of the remaining highmem ones.
|
|
|
|
*
|
|
|
|
* In this approach it is likely that the copies of highmem pages will
|
|
|
|
* also be located in the high memory, because of the way in which
|
|
|
|
* copy_data_pages() works.
|
|
|
|
*/
|
|
|
|
|
2006-09-26 00:32:54 -06:00
|
|
|
static int
|
|
|
|
swsusp_alloc(struct memory_bitmap *orig_bm, struct memory_bitmap *copy_bm,
|
[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-06 21:34:18 -07:00
|
|
|
unsigned int nr_pages, unsigned int nr_highmem)
|
2005-11-08 22:34:39 -07:00
|
|
|
{
|
[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-06 21:34:18 -07:00
|
|
|
if (nr_highmem > 0) {
|
2011-02-12 13:06:51 -07:00
|
|
|
if (get_highmem_buffer(PG_ANY))
|
2009-07-08 05:24:05 -06:00
|
|
|
goto err_out;
|
|
|
|
if (nr_highmem > alloc_highmem) {
|
|
|
|
nr_highmem -= alloc_highmem;
|
|
|
|
nr_pages += alloc_highmem_pages(copy_bm, nr_highmem);
|
|
|
|
}
|
[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-06 21:34:18 -07:00
|
|
|
}
|
2009-07-08 05:24:05 -06:00
|
|
|
if (nr_pages > alloc_normal) {
|
|
|
|
nr_pages -= alloc_normal;
|
|
|
|
while (nr_pages-- > 0) {
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = alloc_image_page(GFP_ATOMIC | __GFP_COLD);
|
|
|
|
if (!page)
|
|
|
|
goto err_out;
|
|
|
|
memory_bm_set_bit(copy_bm, page_to_pfn(page));
|
|
|
|
}
|
2005-10-30 15:59:56 -07:00
|
|
|
}
|
2009-07-08 05:24:05 -06:00
|
|
|
|
2006-09-26 00:32:54 -06:00
|
|
|
return 0;
|
2005-10-30 15:59:56 -07:00
|
|
|
|
2009-07-08 05:24:05 -06:00
|
|
|
err_out:
|
2006-09-26 00:32:54 -06:00
|
|
|
swsusp_free();
|
2011-02-12 13:06:51 -07:00
|
|
|
return -ENOMEM;
|
2005-10-30 15:59:56 -07:00
|
|
|
}
|
|
|
|
|
2005-10-30 16:00:00 -07:00
|
|
|
asmlinkage int swsusp_save(void)
|
2005-10-30 15:59:56 -07:00
|
|
|
{
|
[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-06 21:34:18 -07:00
|
|
|
unsigned int nr_pages, nr_highmem;
|
2005-10-30 15:59:56 -07:00
|
|
|
|
2010-02-11 15:09:08 -07:00
|
|
|
printk(KERN_INFO "PM: Creating hibernation image:\n");
|
2005-10-30 15:59:56 -07:00
|
|
|
|
2008-02-04 23:29:11 -07:00
|
|
|
drain_local_pages(NULL);
|
2005-10-30 15:59:57 -07:00
|
|
|
nr_pages = count_data_pages();
|
[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-06 21:34:18 -07:00
|
|
|
nr_highmem = count_highmem_pages();
|
2007-12-07 18:09:43 -07:00
|
|
|
printk(KERN_INFO "PM: Need to copy %u pages\n", nr_pages + nr_highmem);
|
2005-10-30 15:59:56 -07:00
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
if (!enough_free_mem(nr_pages, nr_highmem)) {
|
2007-12-07 18:09:43 -07:00
|
|
|
printk(KERN_ERR "PM: Not enough free memory\n");
|
2005-10-30 15:59:56 -07:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
if (swsusp_alloc(&orig_bm, ©_bm, nr_pages, nr_highmem)) {
|
2007-12-07 18:09:43 -07:00
|
|
|
printk(KERN_ERR "PM: Memory allocation failed\n");
|
2005-10-30 15:59:57 -07:00
|
|
|
return -ENOMEM;
|
[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-06 21:34:18 -07:00
|
|
|
}
|
2005-10-30 15:59:56 -07:00
|
|
|
|
|
|
|
/* During allocating of suspend pagedir, new cold pages may appear.
|
|
|
|
* Kill them.
|
|
|
|
*/
|
2008-02-04 23:29:11 -07:00
|
|
|
drain_local_pages(NULL);
|
2006-09-26 00:32:54 -06:00
|
|
|
copy_data_pages(©_bm, &orig_bm);
|
2005-10-30 15:59:56 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* End of critical section. From now on, we can write to memory,
|
|
|
|
* but we should not touch disk. This specially means we must _not_
|
|
|
|
* touch swap space! Except we must write out our image of course.
|
|
|
|
*/
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
nr_pages += nr_highmem;
|
2005-10-30 15:59:57 -07:00
|
|
|
nr_copy_pages = nr_pages;
|
[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-06 21:34:18 -07:00
|
|
|
nr_meta_pages = DIV_ROUND_UP(nr_pages * sizeof(long), PAGE_SIZE);
|
2005-10-30 15:59:57 -07:00
|
|
|
|
2007-12-07 18:09:43 -07:00
|
|
|
printk(KERN_INFO "PM: Hibernation image created (%d pages copied)\n",
|
|
|
|
nr_pages);
|
[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-06 21:34:18 -07:00
|
|
|
|
2005-10-30 15:59:56 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2006-03-23 03:59:59 -07:00
|
|
|
|
2007-10-18 04:04:52 -06:00
|
|
|
#ifndef CONFIG_ARCH_HIBERNATION_HEADER
|
|
|
|
static int init_header_complete(struct swsusp_info *info)
|
2006-03-23 03:59:59 -07:00
|
|
|
{
|
2007-10-18 04:04:52 -06:00
|
|
|
memcpy(&info->uts, init_utsname(), sizeof(struct new_utsname));
|
2006-03-23 03:59:59 -07:00
|
|
|
info->version_code = LINUX_VERSION_CODE;
|
2007-10-18 04:04:52 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *check_image_kernel(struct swsusp_info *info)
|
|
|
|
{
|
|
|
|
if (info->version_code != LINUX_VERSION_CODE)
|
|
|
|
return "kernel version";
|
|
|
|
if (strcmp(info->uts.sysname,init_utsname()->sysname))
|
|
|
|
return "system type";
|
|
|
|
if (strcmp(info->uts.release,init_utsname()->release))
|
|
|
|
return "kernel release";
|
|
|
|
if (strcmp(info->uts.version,init_utsname()->version))
|
|
|
|
return "version";
|
|
|
|
if (strcmp(info->uts.machine,init_utsname()->machine))
|
|
|
|
return "machine";
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_ARCH_HIBERNATION_HEADER */
|
|
|
|
|
2007-10-25 16:59:31 -06:00
|
|
|
unsigned long snapshot_get_image_size(void)
|
|
|
|
{
|
|
|
|
return nr_copy_pages + nr_meta_pages + 1;
|
|
|
|
}
|
|
|
|
|
2007-10-18 04:04:52 -06:00
|
|
|
static int init_header(struct swsusp_info *info)
|
|
|
|
{
|
|
|
|
memset(info, 0, sizeof(struct swsusp_info));
|
2013-07-03 16:03:43 -06:00
|
|
|
info->num_physpages = get_num_physpages();
|
2006-03-23 03:59:59 -07:00
|
|
|
info->image_pages = nr_copy_pages;
|
2007-10-25 16:59:31 -06:00
|
|
|
info->pages = snapshot_get_image_size();
|
2006-03-23 04:00:03 -07:00
|
|
|
info->size = info->pages;
|
|
|
|
info->size <<= PAGE_SHIFT;
|
2007-10-18 04:04:52 -06:00
|
|
|
return init_header_complete(info);
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
[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 00:32:55 -06:00
|
|
|
* pack_pfns - pfns corresponding to the set bits found in the bitmap @bm
|
|
|
|
* are stored in the array @buf[] (1 page at a time)
|
2006-03-23 03:59:59 -07:00
|
|
|
*/
|
|
|
|
|
2006-09-26 00:32:54 -06:00
|
|
|
static inline void
|
[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 00:32:55 -06:00
|
|
|
pack_pfns(unsigned long *buf, struct memory_bitmap *bm)
|
2006-03-23 03:59:59 -07:00
|
|
|
{
|
|
|
|
int j;
|
|
|
|
|
2006-09-26 00:32:54 -06:00
|
|
|
for (j = 0; j < PAGE_SIZE / sizeof(long); j++) {
|
[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 00:32:55 -06:00
|
|
|
buf[j] = memory_bm_next_pfn(bm);
|
|
|
|
if (unlikely(buf[j] == BM_END_OF_MAP))
|
2006-09-26 00:32:54 -06:00
|
|
|
break;
|
2011-08-17 12:42:24 -06:00
|
|
|
/* Save page key for data page (s390 only). */
|
|
|
|
page_key_read(buf + j);
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snapshot_read_next - used for reading the system memory snapshot.
|
|
|
|
*
|
|
|
|
* On the first call to it @handle should point to a zeroed
|
|
|
|
* snapshot_handle structure. The structure gets updated and a pointer
|
|
|
|
* to it should be passed to this function every next time.
|
|
|
|
*
|
|
|
|
* On success the function returns a positive number. Then, the caller
|
|
|
|
* is allowed to read up to the returned number of bytes from the memory
|
2010-05-01 15:52:02 -06:00
|
|
|
* location computed by the data_of() macro.
|
2006-03-23 03:59:59 -07:00
|
|
|
*
|
|
|
|
* The function returns 0 to indicate the end of data stream condition,
|
|
|
|
* and a negative number is returned on error. In such cases the
|
|
|
|
* structure pointed to by @handle is not updated and should not be used
|
|
|
|
* any more.
|
|
|
|
*/
|
|
|
|
|
2010-05-01 15:52:02 -06:00
|
|
|
int snapshot_read_next(struct snapshot_handle *handle)
|
2006-03-23 03:59:59 -07:00
|
|
|
{
|
2006-09-26 00:32:46 -06:00
|
|
|
if (handle->cur > nr_meta_pages + nr_copy_pages)
|
2006-03-23 03:59:59 -07:00
|
|
|
return 0;
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2006-03-23 03:59:59 -07:00
|
|
|
if (!buffer) {
|
|
|
|
/* This makes the buffer be freed by swsusp_free() */
|
[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-06 21:34:18 -07:00
|
|
|
buffer = get_image_page(GFP_ATOMIC, PG_ANY);
|
2006-03-23 03:59:59 -07:00
|
|
|
if (!buffer)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2010-05-01 15:52:02 -06:00
|
|
|
if (!handle->cur) {
|
2007-10-18 04:04:52 -06:00
|
|
|
int error;
|
|
|
|
|
|
|
|
error = init_header((struct swsusp_info *)buffer);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2006-03-23 03:59:59 -07:00
|
|
|
handle->buffer = buffer;
|
2006-09-26 00:32:54 -06:00
|
|
|
memory_bm_position_reset(&orig_bm);
|
|
|
|
memory_bm_position_reset(©_bm);
|
2010-05-01 15:52:02 -06:00
|
|
|
} else if (handle->cur <= nr_meta_pages) {
|
2010-10-26 15:22:27 -06:00
|
|
|
clear_page(buffer);
|
2010-05-01 15:52:02 -06:00
|
|
|
pack_pfns(buffer, &orig_bm);
|
|
|
|
} else {
|
|
|
|
struct page *page;
|
2006-09-26 00:32:54 -06:00
|
|
|
|
2010-05-01 15:52:02 -06:00
|
|
|
page = pfn_to_page(memory_bm_next_pfn(©_bm));
|
|
|
|
if (PageHighMem(page)) {
|
|
|
|
/* Highmem pages are copied to the buffer,
|
|
|
|
* because we can't return with a kmapped
|
|
|
|
* highmem page (we may not be called again).
|
|
|
|
*/
|
|
|
|
void *kaddr;
|
[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-06 21:34:18 -07:00
|
|
|
|
2011-11-25 08:14:38 -07:00
|
|
|
kaddr = kmap_atomic(page);
|
2010-10-26 15:22:27 -06:00
|
|
|
copy_page(buffer, kaddr);
|
2011-11-25 08:14:38 -07:00
|
|
|
kunmap_atomic(kaddr);
|
2010-05-01 15:52:02 -06:00
|
|
|
handle->buffer = buffer;
|
|
|
|
} else {
|
|
|
|
handle->buffer = page_address(page);
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
|
|
|
}
|
2010-05-01 15:52:02 -06:00
|
|
|
handle->cur++;
|
|
|
|
return PAGE_SIZE;
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mark_unsafe_pages - mark the pages that cannot be used for storing
|
|
|
|
* the image during resume, because they conflict with the pages that
|
|
|
|
* had been used before suspend
|
|
|
|
*/
|
|
|
|
|
[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 00:32:55 -06:00
|
|
|
static int mark_unsafe_pages(struct memory_bitmap *bm)
|
2006-03-23 03:59:59 -07:00
|
|
|
{
|
|
|
|
struct zone *zone;
|
2006-09-26 00:32:45 -06:00
|
|
|
unsigned long pfn, max_zone_pfn;
|
2006-03-23 03:59:59 -07:00
|
|
|
|
|
|
|
/* Clear page flags */
|
PM / Hibernate / Memory hotplug: Always use for_each_populated_zone()
Use for_each_populated_zone() instead of for_each_zone() in hibernation
code. This fixes a bug on s390, where we allow both config options
HIBERNATION and MEMORY_HOTPLUG, so that we also have a ZONE_MOVABLE
here. We only allow hibernation if no memory hotplug operation was
performed, so in fact both features can only be used exclusively, but
this way we don't need 2 differently configured (distribution) kernels.
If we have an unpopulated ZONE_MOVABLE, we allow hibernation but run
into a BUG_ON() in memory_bm_test/set/clear_bit() because hibernation
code iterates through all zones, not only the populated zones, in
several places. For example, swsusp_free() does for_each_zone() and
then checks for pfn_valid(), which is true even if the zone is not
populated, resulting in a BUG_ON() later because the pfn cannot be
found in the memory bitmap.
Replacing all occurences of for_each_zone() in hibernation code with
for_each_populated_zone() would fix this issue.
[rjw: Rebased on top of linux-next hibernation patches.]
Signed-off-by: Gerald Schaefer <gerald.schaefer@de.ibm.com>
Acked-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2009-07-21 16:36:56 -06:00
|
|
|
for_each_populated_zone(zone) {
|
2013-09-11 15:21:44 -06:00
|
|
|
max_zone_pfn = zone_end_pfn(zone);
|
2006-09-26 00:32:45 -06:00
|
|
|
for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
|
|
|
|
if (pfn_valid(pfn))
|
2007-05-06 15:50:42 -06:00
|
|
|
swsusp_unset_page_free(pfn_to_page(pfn));
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
|
|
|
|
[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 00:32:55 -06:00
|
|
|
/* Mark pages that correspond to the "original" pfns as "unsafe" */
|
|
|
|
memory_bm_position_reset(bm);
|
|
|
|
do {
|
|
|
|
pfn = memory_bm_next_pfn(bm);
|
|
|
|
if (likely(pfn != BM_END_OF_MAP)) {
|
|
|
|
if (likely(pfn_valid(pfn)))
|
2007-05-06 15:50:42 -06:00
|
|
|
swsusp_set_page_free(pfn_to_page(pfn));
|
[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 00:32:55 -06:00
|
|
|
else
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
} while (pfn != BM_END_OF_MAP);
|
2006-03-23 03:59:59 -07:00
|
|
|
|
[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 00:32:55 -06:00
|
|
|
allocated_unsafe_pages = 0;
|
2006-06-23 03:04:48 -06:00
|
|
|
|
2006-03-23 03:59:59 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
[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 00:32:55 -06:00
|
|
|
static void
|
|
|
|
duplicate_memory_bitmap(struct memory_bitmap *dst, struct memory_bitmap *src)
|
2006-03-23 03:59:59 -07:00
|
|
|
{
|
[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 00:32:55 -06:00
|
|
|
unsigned long pfn;
|
|
|
|
|
|
|
|
memory_bm_position_reset(src);
|
|
|
|
pfn = memory_bm_next_pfn(src);
|
|
|
|
while (pfn != BM_END_OF_MAP) {
|
|
|
|
memory_bm_set_bit(dst, pfn);
|
|
|
|
pfn = memory_bm_next_pfn(src);
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-18 04:04:52 -06:00
|
|
|
static int check_header(struct swsusp_info *info)
|
2006-03-23 03:59:59 -07:00
|
|
|
{
|
2007-10-18 04:04:52 -06:00
|
|
|
char *reason;
|
2006-03-23 03:59:59 -07:00
|
|
|
|
2007-10-18 04:04:52 -06:00
|
|
|
reason = check_image_kernel(info);
|
2013-07-03 16:03:43 -06:00
|
|
|
if (!reason && info->num_physpages != get_num_physpages())
|
2006-03-23 03:59:59 -07:00
|
|
|
reason = "memory size";
|
|
|
|
if (reason) {
|
2007-12-07 18:09:43 -07:00
|
|
|
printk(KERN_ERR "PM: Image mismatch: %s\n", reason);
|
2006-03-23 03:59:59 -07:00
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* load header - check the image header and copy data from it
|
|
|
|
*/
|
|
|
|
|
[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 00:32:55 -06:00
|
|
|
static int
|
|
|
|
load_header(struct swsusp_info *info)
|
2006-03-23 03:59:59 -07:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
[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 00:32:55 -06:00
|
|
|
restore_pblist = NULL;
|
2006-03-23 03:59:59 -07:00
|
|
|
error = check_header(info);
|
|
|
|
if (!error) {
|
|
|
|
nr_copy_pages = info->image_pages;
|
|
|
|
nr_meta_pages = info->pages - info->image_pages - 1;
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
[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 00:32:55 -06:00
|
|
|
* unpack_orig_pfns - for each element of @buf[] (1 page at a time) set
|
|
|
|
* the corresponding bit in the memory bitmap @bm
|
2006-03-23 03:59:59 -07:00
|
|
|
*/
|
2008-11-11 13:32:44 -07:00
|
|
|
static int unpack_orig_pfns(unsigned long *buf, struct memory_bitmap *bm)
|
2006-03-23 03:59:59 -07:00
|
|
|
{
|
|
|
|
int j;
|
|
|
|
|
[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 00:32:55 -06:00
|
|
|
for (j = 0; j < PAGE_SIZE / sizeof(long); j++) {
|
|
|
|
if (unlikely(buf[j] == BM_END_OF_MAP))
|
|
|
|
break;
|
|
|
|
|
2011-08-17 12:42:24 -06:00
|
|
|
/* Extract and buffer page key for data page (s390 only). */
|
|
|
|
page_key_memorize(buf + j);
|
|
|
|
|
2008-11-11 13:32:44 -07:00
|
|
|
if (memory_bm_pfn_present(bm, buf[j]))
|
|
|
|
memory_bm_set_bit(bm, buf[j]);
|
|
|
|
else
|
|
|
|
return -EFAULT;
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
2008-11-11 13:32:44 -07:00
|
|
|
|
|
|
|
return 0;
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
/* List of "safe" pages that may be used to store data loaded from the suspend
|
|
|
|
* image
|
|
|
|
*/
|
|
|
|
static struct linked_page *safe_pages_list;
|
|
|
|
|
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
/* struct highmem_pbe is used for creating the list of highmem pages that
|
|
|
|
* should be restored atomically during the resume from disk, because the page
|
|
|
|
* frames they have occupied before the suspend are in use.
|
|
|
|
*/
|
|
|
|
struct highmem_pbe {
|
|
|
|
struct page *copy_page; /* data is here now */
|
|
|
|
struct page *orig_page; /* data was here before the suspend */
|
|
|
|
struct highmem_pbe *next;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* List of highmem PBEs needed for restoring the highmem pages that were
|
|
|
|
* allocated before the suspend and included in the suspend image, but have
|
|
|
|
* also been allocated by the "resume" kernel, so their contents cannot be
|
|
|
|
* written directly to their "original" page frames.
|
|
|
|
*/
|
|
|
|
static struct highmem_pbe *highmem_pblist;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* count_highmem_image_pages - compute the number of highmem pages in the
|
|
|
|
* suspend image. The bits in the memory bitmap @bm that correspond to the
|
|
|
|
* image pages are assumed to be set.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int count_highmem_image_pages(struct memory_bitmap *bm)
|
|
|
|
{
|
|
|
|
unsigned long pfn;
|
|
|
|
unsigned int cnt = 0;
|
|
|
|
|
|
|
|
memory_bm_position_reset(bm);
|
|
|
|
pfn = memory_bm_next_pfn(bm);
|
|
|
|
while (pfn != BM_END_OF_MAP) {
|
|
|
|
if (PageHighMem(pfn_to_page(pfn)))
|
|
|
|
cnt++;
|
|
|
|
|
|
|
|
pfn = memory_bm_next_pfn(bm);
|
|
|
|
}
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* prepare_highmem_image - try to allocate as many highmem pages as
|
|
|
|
* there are highmem image pages (@nr_highmem_p points to the variable
|
|
|
|
* containing the number of highmem image pages). The pages that are
|
|
|
|
* "safe" (ie. will not be overwritten when the suspend image is
|
|
|
|
* restored) have the corresponding bits set in @bm (it must be
|
|
|
|
* unitialized).
|
|
|
|
*
|
|
|
|
* NOTE: This function should not be called if there are no highmem
|
|
|
|
* image pages.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int safe_highmem_pages;
|
|
|
|
|
|
|
|
static struct memory_bitmap *safe_highmem_bm;
|
|
|
|
|
|
|
|
static int
|
|
|
|
prepare_highmem_image(struct memory_bitmap *bm, unsigned int *nr_highmem_p)
|
|
|
|
{
|
|
|
|
unsigned int to_alloc;
|
|
|
|
|
|
|
|
if (memory_bm_create(bm, GFP_ATOMIC, PG_SAFE))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (get_highmem_buffer(PG_SAFE))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
to_alloc = count_free_highmem_pages();
|
|
|
|
if (to_alloc > *nr_highmem_p)
|
|
|
|
to_alloc = *nr_highmem_p;
|
|
|
|
else
|
|
|
|
*nr_highmem_p = to_alloc;
|
|
|
|
|
|
|
|
safe_highmem_pages = 0;
|
|
|
|
while (to_alloc-- > 0) {
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = alloc_page(__GFP_HIGHMEM);
|
2007-05-06 15:50:42 -06:00
|
|
|
if (!swsusp_page_is_free(page)) {
|
[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-06 21:34:18 -07:00
|
|
|
/* The page is "safe", set its bit the bitmap */
|
|
|
|
memory_bm_set_bit(bm, page_to_pfn(page));
|
|
|
|
safe_highmem_pages++;
|
|
|
|
}
|
|
|
|
/* Mark the page as allocated */
|
2007-05-06 15:50:42 -06:00
|
|
|
swsusp_set_page_forbidden(page);
|
|
|
|
swsusp_set_page_free(page);
|
[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-06 21:34:18 -07:00
|
|
|
}
|
|
|
|
memory_bm_position_reset(bm);
|
|
|
|
safe_highmem_bm = bm;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get_highmem_page_buffer - for given highmem image page find the buffer
|
|
|
|
* that suspend_write_next() should set for its caller to write to.
|
|
|
|
*
|
|
|
|
* If the page is to be saved to its "original" page frame or a copy of
|
|
|
|
* the page is to be made in the highmem, @buffer is returned. Otherwise,
|
|
|
|
* the copy of the page is to be made in normal memory, so the address of
|
|
|
|
* the copy is returned.
|
|
|
|
*
|
|
|
|
* If @buffer is returned, the caller of suspend_write_next() will write
|
|
|
|
* the page's contents to @buffer, so they will have to be copied to the
|
|
|
|
* right location on the next call to suspend_write_next() and it is done
|
|
|
|
* with the help of copy_last_highmem_page(). For this purpose, if
|
|
|
|
* @buffer is returned, @last_highmem page is set to the page to which
|
|
|
|
* the data will have to be copied from @buffer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static struct page *last_highmem_page;
|
|
|
|
|
|
|
|
static void *
|
|
|
|
get_highmem_page_buffer(struct page *page, struct chain_allocator *ca)
|
|
|
|
{
|
|
|
|
struct highmem_pbe *pbe;
|
|
|
|
void *kaddr;
|
|
|
|
|
2007-05-06 15:50:42 -06:00
|
|
|
if (swsusp_page_is_forbidden(page) && swsusp_page_is_free(page)) {
|
[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-06 21:34:18 -07:00
|
|
|
/* We have allocated the "original" page frame and we can
|
|
|
|
* use it directly to store the loaded page.
|
|
|
|
*/
|
|
|
|
last_highmem_page = page;
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
/* The "original" page frame has not been allocated and we have to
|
|
|
|
* use a "safe" page frame to store the loaded page.
|
|
|
|
*/
|
|
|
|
pbe = chain_alloc(ca, sizeof(struct highmem_pbe));
|
|
|
|
if (!pbe) {
|
|
|
|
swsusp_free();
|
2008-11-11 13:32:44 -07:00
|
|
|
return ERR_PTR(-ENOMEM);
|
[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-06 21:34:18 -07:00
|
|
|
}
|
|
|
|
pbe->orig_page = page;
|
|
|
|
if (safe_highmem_pages > 0) {
|
|
|
|
struct page *tmp;
|
|
|
|
|
|
|
|
/* Copy of the page will be stored in high memory */
|
|
|
|
kaddr = buffer;
|
|
|
|
tmp = pfn_to_page(memory_bm_next_pfn(safe_highmem_bm));
|
|
|
|
safe_highmem_pages--;
|
|
|
|
last_highmem_page = tmp;
|
|
|
|
pbe->copy_page = tmp;
|
|
|
|
} else {
|
|
|
|
/* Copy of the page will be stored in normal memory */
|
|
|
|
kaddr = safe_pages_list;
|
|
|
|
safe_pages_list = safe_pages_list->next;
|
|
|
|
pbe->copy_page = virt_to_page(kaddr);
|
|
|
|
}
|
|
|
|
pbe->next = highmem_pblist;
|
|
|
|
highmem_pblist = pbe;
|
|
|
|
return kaddr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* copy_last_highmem_page - copy the contents of a highmem image from
|
|
|
|
* @buffer, where the caller of snapshot_write_next() has place them,
|
|
|
|
* to the right location represented by @last_highmem_page .
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void copy_last_highmem_page(void)
|
|
|
|
{
|
|
|
|
if (last_highmem_page) {
|
|
|
|
void *dst;
|
|
|
|
|
2011-11-25 08:14:38 -07:00
|
|
|
dst = kmap_atomic(last_highmem_page);
|
2010-10-26 15:22:27 -06:00
|
|
|
copy_page(dst, buffer);
|
2011-11-25 08:14:38 -07:00
|
|
|
kunmap_atomic(dst);
|
[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-06 21:34:18 -07:00
|
|
|
last_highmem_page = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int last_highmem_page_copied(void)
|
|
|
|
{
|
|
|
|
return !last_highmem_page;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void free_highmem_data(void)
|
|
|
|
{
|
|
|
|
if (safe_highmem_bm)
|
|
|
|
memory_bm_free(safe_highmem_bm, PG_UNSAFE_CLEAR);
|
|
|
|
|
|
|
|
if (buffer)
|
|
|
|
free_image_page(buffer, PG_UNSAFE_CLEAR);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline int get_safe_write_buffer(void) { return 0; }
|
|
|
|
|
|
|
|
static unsigned int
|
|
|
|
count_highmem_image_pages(struct memory_bitmap *bm) { return 0; }
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
prepare_highmem_image(struct memory_bitmap *bm, unsigned int *nr_highmem_p)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *
|
|
|
|
get_highmem_page_buffer(struct page *page, struct chain_allocator *ca)
|
|
|
|
{
|
2008-11-11 13:32:44 -07:00
|
|
|
return ERR_PTR(-EINVAL);
|
[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-06 21:34:18 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void copy_last_highmem_page(void) {}
|
|
|
|
static inline int last_highmem_page_copied(void) { return 1; }
|
|
|
|
static inline void free_highmem_data(void) {}
|
|
|
|
#endif /* CONFIG_HIGHMEM */
|
|
|
|
|
2006-03-23 03:59:59 -07:00
|
|
|
/**
|
[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 00:32:55 -06:00
|
|
|
* prepare_image - use the memory bitmap @bm to mark the pages that will
|
|
|
|
* be overwritten in the process of restoring the system memory state
|
|
|
|
* from the suspend image ("unsafe" pages) and allocate memory for the
|
|
|
|
* image.
|
2006-06-23 03:04:48 -06:00
|
|
|
*
|
[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 00:32:55 -06:00
|
|
|
* The idea is to allocate a new memory bitmap first and then allocate
|
|
|
|
* as many pages as needed for the image data, but not to assign these
|
|
|
|
* pages to specific tasks initially. Instead, we just mark them as
|
[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-06 21:34:18 -07:00
|
|
|
* allocated and create a lists of "safe" pages that will be used
|
|
|
|
* later. On systems with high memory a list of "safe" highmem pages is
|
|
|
|
* also created.
|
2006-03-23 03:59:59 -07:00
|
|
|
*/
|
|
|
|
|
[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 00:32:55 -06:00
|
|
|
#define PBES_PER_LINKED_PAGE (LINKED_PAGE_DATA_SIZE / sizeof(struct pbe))
|
|
|
|
|
|
|
|
static int
|
|
|
|
prepare_image(struct memory_bitmap *new_bm, struct memory_bitmap *bm)
|
2006-03-23 03:59:59 -07:00
|
|
|
{
|
[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-06 21:34:18 -07:00
|
|
|
unsigned int nr_pages, nr_highmem;
|
[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 00:32:55 -06:00
|
|
|
struct linked_page *sp_list, *lp;
|
|
|
|
int error;
|
2006-03-23 03:59:59 -07:00
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
/* If there is no highmem, the buffer will not be necessary */
|
|
|
|
free_image_page(buffer, PG_UNSAFE_CLEAR);
|
|
|
|
buffer = NULL;
|
|
|
|
|
|
|
|
nr_highmem = count_highmem_image_pages(bm);
|
[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 00:32:55 -06:00
|
|
|
error = mark_unsafe_pages(bm);
|
|
|
|
if (error)
|
|
|
|
goto Free;
|
|
|
|
|
|
|
|
error = memory_bm_create(new_bm, GFP_ATOMIC, PG_SAFE);
|
|
|
|
if (error)
|
|
|
|
goto Free;
|
|
|
|
|
|
|
|
duplicate_memory_bitmap(new_bm, bm);
|
|
|
|
memory_bm_free(bm, PG_UNSAFE_KEEP);
|
[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-06 21:34:18 -07:00
|
|
|
if (nr_highmem > 0) {
|
|
|
|
error = prepare_highmem_image(bm, &nr_highmem);
|
|
|
|
if (error)
|
|
|
|
goto Free;
|
|
|
|
}
|
[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 00:32:55 -06:00
|
|
|
/* Reserve some safe pages for potential later use.
|
|
|
|
*
|
|
|
|
* NOTE: This way we make sure there will be enough safe pages for the
|
|
|
|
* chain_alloc() in get_buffer(). It is a bit wasteful, but
|
|
|
|
* nr_copy_pages cannot be greater than 50% of the memory anyway.
|
|
|
|
*/
|
|
|
|
sp_list = NULL;
|
|
|
|
/* nr_copy_pages cannot be lesser than allocated_unsafe_pages */
|
[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-06 21:34:18 -07:00
|
|
|
nr_pages = nr_copy_pages - nr_highmem - allocated_unsafe_pages;
|
[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 00:32:55 -06:00
|
|
|
nr_pages = DIV_ROUND_UP(nr_pages, PBES_PER_LINKED_PAGE);
|
|
|
|
while (nr_pages > 0) {
|
[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-06 21:34:18 -07:00
|
|
|
lp = get_image_page(GFP_ATOMIC, PG_SAFE);
|
[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 00:32:55 -06:00
|
|
|
if (!lp) {
|
2006-03-23 03:59:59 -07:00
|
|
|
error = -ENOMEM;
|
[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 00:32:55 -06:00
|
|
|
goto Free;
|
|
|
|
}
|
|
|
|
lp->next = sp_list;
|
|
|
|
sp_list = lp;
|
|
|
|
nr_pages--;
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
[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 00:32:55 -06:00
|
|
|
/* Preallocate memory for the image */
|
|
|
|
safe_pages_list = NULL;
|
[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-06 21:34:18 -07:00
|
|
|
nr_pages = nr_copy_pages - nr_highmem - allocated_unsafe_pages;
|
[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 00:32:55 -06:00
|
|
|
while (nr_pages > 0) {
|
|
|
|
lp = (struct linked_page *)get_zeroed_page(GFP_ATOMIC);
|
|
|
|
if (!lp) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto Free;
|
|
|
|
}
|
2007-05-06 15:50:42 -06:00
|
|
|
if (!swsusp_page_is_free(virt_to_page(lp))) {
|
[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 00:32:55 -06:00
|
|
|
/* The page is "safe", add it to the list */
|
|
|
|
lp->next = safe_pages_list;
|
|
|
|
safe_pages_list = lp;
|
2006-06-23 03:04:48 -06:00
|
|
|
}
|
[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 00:32:55 -06:00
|
|
|
/* Mark the page as allocated */
|
2007-05-06 15:50:42 -06:00
|
|
|
swsusp_set_page_forbidden(virt_to_page(lp));
|
|
|
|
swsusp_set_page_free(virt_to_page(lp));
|
[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 00:32:55 -06:00
|
|
|
nr_pages--;
|
2006-06-23 03:04:48 -06:00
|
|
|
}
|
[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 00:32:55 -06:00
|
|
|
/* Free the reserved safe pages so that chain_alloc() can use them */
|
|
|
|
while (sp_list) {
|
|
|
|
lp = sp_list->next;
|
|
|
|
free_image_page(sp_list, PG_UNSAFE_CLEAR);
|
|
|
|
sp_list = lp;
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
[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 00:32:55 -06:00
|
|
|
return 0;
|
|
|
|
|
2006-12-06 21:34:44 -07:00
|
|
|
Free:
|
[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 00:32:55 -06:00
|
|
|
swsusp_free();
|
2006-03-23 03:59:59 -07:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
[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 00:32:55 -06:00
|
|
|
/**
|
|
|
|
* get_buffer - compute the address that snapshot_write_next() should
|
|
|
|
* set for its caller to write to.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void *get_buffer(struct memory_bitmap *bm, struct chain_allocator *ca)
|
2006-06-23 03:04:48 -06:00
|
|
|
{
|
[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 00:32:55 -06:00
|
|
|
struct pbe *pbe;
|
2008-11-11 13:32:44 -07:00
|
|
|
struct page *page;
|
|
|
|
unsigned long pfn = memory_bm_next_pfn(bm);
|
2006-06-23 03:04:48 -06:00
|
|
|
|
2008-11-11 13:32:44 -07:00
|
|
|
if (pfn == BM_END_OF_MAP)
|
|
|
|
return ERR_PTR(-EFAULT);
|
|
|
|
|
|
|
|
page = pfn_to_page(pfn);
|
[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-06 21:34:18 -07:00
|
|
|
if (PageHighMem(page))
|
|
|
|
return get_highmem_page_buffer(page, ca);
|
|
|
|
|
2007-05-06 15:50:42 -06:00
|
|
|
if (swsusp_page_is_forbidden(page) && swsusp_page_is_free(page))
|
[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 00:32:55 -06:00
|
|
|
/* We have allocated the "original" page frame and we can
|
|
|
|
* use it directly to store the loaded page.
|
2006-06-23 03:04:48 -06:00
|
|
|
*/
|
[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 00:32:55 -06:00
|
|
|
return page_address(page);
|
|
|
|
|
|
|
|
/* The "original" page frame has not been allocated and we have to
|
|
|
|
* use a "safe" page frame to store the loaded page.
|
2006-06-23 03:04:48 -06:00
|
|
|
*/
|
[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 00:32:55 -06:00
|
|
|
pbe = chain_alloc(ca, sizeof(struct pbe));
|
|
|
|
if (!pbe) {
|
|
|
|
swsusp_free();
|
2008-11-11 13:32:44 -07:00
|
|
|
return ERR_PTR(-ENOMEM);
|
[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 00:32:55 -06:00
|
|
|
}
|
[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-06 21:34:18 -07:00
|
|
|
pbe->orig_address = page_address(page);
|
|
|
|
pbe->address = safe_pages_list;
|
[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 00:32:55 -06:00
|
|
|
safe_pages_list = safe_pages_list->next;
|
|
|
|
pbe->next = restore_pblist;
|
|
|
|
restore_pblist = pbe;
|
[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-06 21:34:18 -07:00
|
|
|
return pbe->address;
|
2006-06-23 03:04:48 -06:00
|
|
|
}
|
|
|
|
|
2006-03-23 03:59:59 -07:00
|
|
|
/**
|
|
|
|
* snapshot_write_next - used for writing the system memory snapshot.
|
|
|
|
*
|
|
|
|
* On the first call to it @handle should point to a zeroed
|
|
|
|
* snapshot_handle structure. The structure gets updated and a pointer
|
|
|
|
* to it should be passed to this function every next time.
|
|
|
|
*
|
|
|
|
* On success the function returns a positive number. Then, the caller
|
|
|
|
* is allowed to write up to the returned number of bytes to the memory
|
2010-05-01 15:52:02 -06:00
|
|
|
* location computed by the data_of() macro.
|
2006-03-23 03:59:59 -07:00
|
|
|
*
|
|
|
|
* The function returns 0 to indicate the "end of file" condition,
|
|
|
|
* and a negative number is returned on error. In such cases the
|
|
|
|
* structure pointed to by @handle is not updated and should not be used
|
|
|
|
* any more.
|
|
|
|
*/
|
|
|
|
|
2010-05-01 15:52:02 -06:00
|
|
|
int snapshot_write_next(struct snapshot_handle *handle)
|
2006-03-23 03:59:59 -07:00
|
|
|
{
|
[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 00:32:55 -06:00
|
|
|
static struct chain_allocator ca;
|
2006-03-23 03:59:59 -07:00
|
|
|
int error = 0;
|
|
|
|
|
[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 00:32:55 -06:00
|
|
|
/* Check if we have already loaded the entire image */
|
2010-05-01 15:52:02 -06:00
|
|
|
if (handle->cur > 1 && handle->cur > nr_meta_pages + nr_copy_pages)
|
2006-03-23 03:59:59 -07:00
|
|
|
return 0;
|
[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 00:32:55 -06:00
|
|
|
|
2010-05-01 15:52:02 -06:00
|
|
|
handle->sync_read = 1;
|
|
|
|
|
|
|
|
if (!handle->cur) {
|
[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-06 21:34:18 -07:00
|
|
|
if (!buffer)
|
|
|
|
/* This makes the buffer be freed by swsusp_free() */
|
|
|
|
buffer = get_image_page(GFP_ATOMIC, PG_ANY);
|
|
|
|
|
2006-03-23 03:59:59 -07:00
|
|
|
if (!buffer)
|
|
|
|
return -ENOMEM;
|
[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-06 21:34:18 -07:00
|
|
|
|
2006-03-23 03:59:59 -07:00
|
|
|
handle->buffer = buffer;
|
2010-05-01 15:52:02 -06:00
|
|
|
} else if (handle->cur == 1) {
|
|
|
|
error = load_header(buffer);
|
|
|
|
if (error)
|
|
|
|
return error;
|
[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 00:32:55 -06:00
|
|
|
|
2010-05-01 15:52:02 -06:00
|
|
|
error = memory_bm_create(©_bm, GFP_ATOMIC, PG_ANY);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2011-08-17 12:42:24 -06:00
|
|
|
/* Allocate buffer for page keys. */
|
|
|
|
error = page_key_alloc(nr_copy_pages);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2010-05-01 15:52:02 -06:00
|
|
|
} else if (handle->cur <= nr_meta_pages + 1) {
|
|
|
|
error = unpack_orig_pfns(buffer, ©_bm);
|
|
|
|
if (error)
|
|
|
|
return error;
|
[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 00:32:55 -06:00
|
|
|
|
2010-05-01 15:52:02 -06:00
|
|
|
if (handle->cur == nr_meta_pages + 1) {
|
|
|
|
error = prepare_image(&orig_bm, ©_bm);
|
2008-11-11 13:32:44 -07:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2010-05-01 15:52:02 -06:00
|
|
|
chain_init(&ca, GFP_ATOMIC, PG_SAFE);
|
|
|
|
memory_bm_position_reset(&orig_bm);
|
|
|
|
restore_pblist = NULL;
|
[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 00:32:55 -06:00
|
|
|
handle->buffer = get_buffer(&orig_bm, &ca);
|
2010-05-01 15:52:02 -06:00
|
|
|
handle->sync_read = 0;
|
2008-11-11 13:32:44 -07:00
|
|
|
if (IS_ERR(handle->buffer))
|
|
|
|
return PTR_ERR(handle->buffer);
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
|
|
|
} else {
|
2010-05-01 15:52:02 -06:00
|
|
|
copy_last_highmem_page();
|
2011-08-17 12:42:24 -06:00
|
|
|
/* Restore page key for data page (s390 only). */
|
|
|
|
page_key_write(handle->buffer);
|
2010-05-01 15:52:02 -06:00
|
|
|
handle->buffer = get_buffer(&orig_bm, &ca);
|
|
|
|
if (IS_ERR(handle->buffer))
|
|
|
|
return PTR_ERR(handle->buffer);
|
|
|
|
if (handle->buffer != buffer)
|
|
|
|
handle->sync_read = 0;
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
2010-05-01 15:52:02 -06:00
|
|
|
handle->cur++;
|
|
|
|
return PAGE_SIZE;
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
/**
|
|
|
|
* snapshot_write_finalize - must be called after the last call to
|
|
|
|
* snapshot_write_next() in case the last page in the image happens
|
|
|
|
* to be a highmem page and its contents should be stored in the
|
|
|
|
* highmem. Additionally, it releases the memory that will not be
|
|
|
|
* used any more.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void snapshot_write_finalize(struct snapshot_handle *handle)
|
|
|
|
{
|
|
|
|
copy_last_highmem_page();
|
2011-08-17 12:42:24 -06:00
|
|
|
/* Restore page key for data page (s390 only). */
|
|
|
|
page_key_write(handle->buffer);
|
|
|
|
page_key_free();
|
[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-06 21:34:18 -07:00
|
|
|
/* Free only if we have loaded the image entirely */
|
2010-05-01 15:52:02 -06:00
|
|
|
if (handle->cur > 1 && handle->cur > nr_meta_pages + nr_copy_pages) {
|
[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-06 21:34:18 -07:00
|
|
|
memory_bm_free(&orig_bm, PG_UNSAFE_CLEAR);
|
|
|
|
free_highmem_data();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-03-23 03:59:59 -07:00
|
|
|
int snapshot_image_loaded(struct snapshot_handle *handle)
|
|
|
|
{
|
[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-06 21:34:18 -07:00
|
|
|
return !(!nr_copy_pages || !last_highmem_page_copied() ||
|
[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 00:32:55 -06:00
|
|
|
handle->cur <= nr_meta_pages + nr_copy_pages);
|
|
|
|
}
|
|
|
|
|
[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-06 21:34:18 -07:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
/* Assumes that @buf is ready and points to a "safe" page */
|
|
|
|
static inline void
|
|
|
|
swap_two_pages_data(struct page *p1, struct page *p2, void *buf)
|
[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 00:32:55 -06:00
|
|
|
{
|
[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-06 21:34:18 -07:00
|
|
|
void *kaddr1, *kaddr2;
|
|
|
|
|
2011-11-25 08:14:38 -07:00
|
|
|
kaddr1 = kmap_atomic(p1);
|
|
|
|
kaddr2 = kmap_atomic(p2);
|
2010-10-26 15:22:27 -06:00
|
|
|
copy_page(buf, kaddr1);
|
|
|
|
copy_page(kaddr1, kaddr2);
|
|
|
|
copy_page(kaddr2, buf);
|
2011-11-25 08:14:38 -07:00
|
|
|
kunmap_atomic(kaddr2);
|
|
|
|
kunmap_atomic(kaddr1);
|
[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-06 21:34:18 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* restore_highmem - for each highmem page that was allocated before
|
|
|
|
* the suspend and included in the suspend image, and also has been
|
|
|
|
* allocated by the "resume" kernel swap its current (ie. "before
|
|
|
|
* resume") contents with the previous (ie. "before suspend") one.
|
|
|
|
*
|
|
|
|
* If the resume eventually fails, we can call this function once
|
|
|
|
* again and restore the "before resume" highmem state.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int restore_highmem(void)
|
|
|
|
{
|
|
|
|
struct highmem_pbe *pbe = highmem_pblist;
|
|
|
|
void *buf;
|
|
|
|
|
|
|
|
if (!pbe)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
buf = get_image_page(GFP_ATOMIC, PG_SAFE);
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
while (pbe) {
|
|
|
|
swap_two_pages_data(pbe->copy_page, pbe->orig_page, buf);
|
|
|
|
pbe = pbe->next;
|
|
|
|
}
|
|
|
|
free_image_page(buf, PG_UNSAFE_CLEAR);
|
|
|
|
return 0;
|
2006-03-23 03:59:59 -07:00
|
|
|
}
|
[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-06 21:34:18 -07:00
|
|
|
#endif /* CONFIG_HIGHMEM */
|