2019-06-01 16:08:42 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2005-10-31 06:59:56 +08:00
|
|
|
/*
|
2005-10-31 06:59:58 +08:00
|
|
|
* linux/kernel/power/snapshot.c
|
2005-10-31 06:59:56 +08: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-07 12:34:18 +08:00
|
|
|
* This file provides system snapshot/restore functionality for swsusp.
|
2005-10-31 06:59:56 +08:00
|
|
|
*
|
2010-07-18 20:27:13 +08: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-07 12:34:18 +08:00
|
|
|
* Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
|
2005-10-31 06:59:56 +08:00
|
|
|
*/
|
|
|
|
|
2020-01-03 07:19:40 +08:00
|
|
|
#define pr_fmt(fmt) "PM: hibernation: " fmt
|
2017-09-28 13:01:34 +08:00
|
|
|
|
2006-03-23 18:59:59 +08:00
|
|
|
#include <linux/version.h>
|
2005-10-31 06:59:56 +08: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-07 05:50:43 +08:00
|
|
|
#include <linux/init.h>
|
2018-10-31 06:09:49 +08:00
|
|
|
#include <linux/memblock.h>
|
2017-02-09 01:51:31 +08:00
|
|
|
#include <linux/nmi.h>
|
2005-10-31 06:59:56 +08:00
|
|
|
#include <linux/syscalls.h>
|
|
|
|
#include <linux/console.h>
|
|
|
|
#include <linux/highmem.h>
|
2008-11-27 07:00:24 +08: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 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2014-04-08 06:39:20 +08:00
|
|
|
#include <linux/compiler.h>
|
2014-10-31 02:04:53 +08:00
|
|
|
#include <linux/ktime.h>
|
2017-07-07 06:35:55 +08:00
|
|
|
#include <linux/set_memory.h>
|
2005-10-31 06:59:56 +08:00
|
|
|
|
2016-12-25 03:46:01 +08:00
|
|
|
#include <linux/uaccess.h>
|
2005-10-31 06:59:56 +08:00
|
|
|
#include <asm/mmu_context.h>
|
|
|
|
#include <asm/tlbflush.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
|
|
|
|
#include "power.h"
|
|
|
|
|
2017-06-03 18:52:32 +08:00
|
|
|
#if defined(CONFIG_STRICT_KERNEL_RWX) && defined(CONFIG_ARCH_HAS_SET_MEMORY)
|
2016-07-10 08:12:10 +08:00
|
|
|
static bool hibernate_restore_protection;
|
|
|
|
static bool hibernate_restore_protection_active;
|
|
|
|
|
|
|
|
void enable_restore_image_protection(void)
|
|
|
|
{
|
|
|
|
hibernate_restore_protection = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void hibernate_restore_protection_begin(void)
|
|
|
|
{
|
|
|
|
hibernate_restore_protection_active = hibernate_restore_protection;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void hibernate_restore_protection_end(void)
|
|
|
|
{
|
|
|
|
hibernate_restore_protection_active = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void hibernate_restore_protect_page(void *page_address)
|
|
|
|
{
|
|
|
|
if (hibernate_restore_protection_active)
|
|
|
|
set_memory_ro((unsigned long)page_address, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void hibernate_restore_unprotect_page(void *page_address)
|
|
|
|
{
|
|
|
|
if (hibernate_restore_protection_active)
|
|
|
|
set_memory_rw((unsigned long)page_address, 1);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void hibernate_restore_protection_begin(void) {}
|
|
|
|
static inline void hibernate_restore_protection_end(void) {}
|
|
|
|
static inline void hibernate_restore_protect_page(void *page_address) {}
|
|
|
|
static inline void hibernate_restore_unprotect_page(void *page_address) {}
|
2017-06-03 18:52:32 +08:00
|
|
|
#endif /* CONFIG_STRICT_KERNEL_RWX && CONFIG_ARCH_HAS_SET_MEMORY */
|
2016-07-10 08:12:10 +08:00
|
|
|
|
2020-12-15 11:10:25 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The calls to set_direct_map_*() should not fail because remapping a page
|
|
|
|
* here means that we only update protection bits in an existing PTE.
|
|
|
|
* It is still worth to have a warning here if something changes and this
|
|
|
|
* will no longer be the case.
|
|
|
|
*/
|
|
|
|
static inline void hibernate_map_page(struct page *page)
|
|
|
|
{
|
|
|
|
if (IS_ENABLED(CONFIG_ARCH_HAS_SET_DIRECT_MAP)) {
|
|
|
|
int ret = set_direct_map_default_noflush(page);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
pr_warn_once("Failed to remap page\n");
|
|
|
|
} else {
|
|
|
|
debug_pagealloc_map_pages(page, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void hibernate_unmap_page(struct page *page)
|
|
|
|
{
|
|
|
|
if (IS_ENABLED(CONFIG_ARCH_HAS_SET_DIRECT_MAP)) {
|
|
|
|
unsigned long addr = (unsigned long)page_address(page);
|
|
|
|
int ret = set_direct_map_invalid_noflush(page);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
pr_warn_once("Failed to remap page\n");
|
|
|
|
|
|
|
|
flush_tlb_kernel_range(addr, addr + PAGE_SIZE);
|
|
|
|
} else {
|
|
|
|
debug_pagealloc_unmap_pages(page, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-07 05:50:43 +08: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 17:38:48 +08: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-12 05:11:17 +08:00
|
|
|
/*
|
|
|
|
* Preferred image size in bytes (tunable via /sys/power/image_size).
|
2011-05-15 17:39:48 +08: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-12 05:11:17 +08:00
|
|
|
*/
|
2010-09-21 01:44:56 +08:00
|
|
|
unsigned long image_size;
|
|
|
|
|
|
|
|
void __init hibernate_image_size_init(void)
|
|
|
|
{
|
2018-12-28 16:34:29 +08:00
|
|
|
image_size = ((totalram_pages() * 2) / 5) * PAGE_SIZE;
|
2010-09-21 01:44:56 +08:00
|
|
|
}
|
2009-06-12 05:11:17 +08:00
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* List of PBEs needed for restoring the pages that were allocated before
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
* 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 14:32:52 +08:00
|
|
|
struct pbe *restore_pblist;
|
|
|
|
|
2016-06-29 09:00:51 +08: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];
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* List of "safe" pages (ie. pages that were not used by the image kernel
|
|
|
|
* before hibernation) that may be used as temporary storage for image kernel
|
|
|
|
* memory contents.
|
|
|
|
*/
|
|
|
|
static struct linked_page *safe_pages_list;
|
|
|
|
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08: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 14:32:55 +08:00
|
|
|
static void *buffer;
|
2006-01-06 16:13:05 +08:00
|
|
|
|
2006-09-26 14:32:52 +08: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 14:32:55 +08:00
|
|
|
static unsigned int allocated_unsafe_pages;
|
2006-09-26 14:32:50 +08:00
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/**
|
|
|
|
* get_image_page - Allocate a page for a hibernation image.
|
|
|
|
* @gfp_mask: GFP mask for the allocation.
|
|
|
|
* @safe_needed: Get pages that were not used before hibernation (restore only)
|
|
|
|
*
|
|
|
|
* During image restoration, for storing the PBE list and the image data, we can
|
|
|
|
* only use memory pages that do not conflict with the pages used before
|
|
|
|
* hibernation. The "unsafe" pages have PageNosaveFree set and we count them
|
|
|
|
* using allocated_unsafe_pages.
|
|
|
|
*
|
|
|
|
* Each allocated image page is marked as PageNosave and PageNosaveFree so that
|
|
|
|
* swsusp_free() can release it.
|
|
|
|
*/
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
static void *get_image_page(gfp_t gfp_mask, int safe_needed)
|
2006-09-26 14:32:50 +08:00
|
|
|
{
|
|
|
|
void *res;
|
|
|
|
|
|
|
|
res = (void *)get_zeroed_page(gfp_mask);
|
|
|
|
if (safe_needed)
|
2007-05-07 05:50:42 +08:00
|
|
|
while (res && swsusp_page_is_free(virt_to_page(res))) {
|
2006-09-26 14:32:50 +08:00
|
|
|
/* The page is unsafe, mark it for swsusp_free() */
|
2007-05-07 05:50:42 +08: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 14:32:55 +08:00
|
|
|
allocated_unsafe_pages++;
|
2006-09-26 14:32:50 +08:00
|
|
|
res = (void *)get_zeroed_page(gfp_mask);
|
|
|
|
}
|
|
|
|
if (res) {
|
2007-05-07 05:50:42 +08:00
|
|
|
swsusp_set_page_forbidden(virt_to_page(res));
|
|
|
|
swsusp_set_page_free(virt_to_page(res));
|
2006-09-26 14:32:50 +08:00
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2016-06-29 09:00:51 +08:00
|
|
|
static void *__get_safe_page(gfp_t gfp_mask)
|
|
|
|
{
|
|
|
|
if (safe_pages_list) {
|
|
|
|
void *ret = safe_pages_list;
|
|
|
|
|
|
|
|
safe_pages_list = safe_pages_list->next;
|
|
|
|
memset(ret, 0, PAGE_SIZE);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
return get_image_page(gfp_mask, PG_SAFE);
|
|
|
|
}
|
|
|
|
|
2006-09-26 14:32:50 +08:00
|
|
|
unsigned long get_safe_page(gfp_t gfp_mask)
|
|
|
|
{
|
2016-06-29 09:00:51 +08:00
|
|
|
return (unsigned long)__get_safe_page(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-07 12:34:18 +08:00
|
|
|
}
|
|
|
|
|
2006-12-07 12:34:43 +08: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-07 12:34:18 +08:00
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = alloc_page(gfp_mask);
|
|
|
|
if (page) {
|
2007-05-07 05:50:42 +08: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-07 12:34:18 +08:00
|
|
|
}
|
|
|
|
return page;
|
2006-09-26 14:32:50 +08:00
|
|
|
}
|
|
|
|
|
2016-06-29 09:05:10 +08:00
|
|
|
static void recycle_safe_page(void *page_address)
|
|
|
|
{
|
|
|
|
struct linked_page *lp = page_address;
|
|
|
|
|
|
|
|
lp->next = safe_pages_list;
|
|
|
|
safe_pages_list = lp;
|
|
|
|
}
|
|
|
|
|
2006-09-26 14:32:50 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* free_image_page - Free a page allocated for hibernation image.
|
|
|
|
* @addr: Address of the page to free.
|
|
|
|
* @clear_nosave_free: If set, clear the PageNosaveFree bit for the page.
|
|
|
|
*
|
|
|
|
* The page to free should have been allocated by get_image_page() (page flags
|
|
|
|
* set by it are affected).
|
2006-09-26 14:32:50 +08: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-07 12:34:18 +08:00
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
BUG_ON(!virt_addr_valid(addr));
|
|
|
|
|
|
|
|
page = virt_to_page(addr);
|
|
|
|
|
2007-05-07 05:50:42 +08:00
|
|
|
swsusp_unset_page_forbidden(page);
|
2006-09-26 14:32:50 +08:00
|
|
|
if (clear_nosave_free)
|
2007-05-07 05:50:42 +08: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-07 12:34:18 +08:00
|
|
|
|
|
|
|
__free_page(page);
|
2006-09-26 14:32:50 +08:00
|
|
|
}
|
|
|
|
|
2016-07-07 05:42:46 +08:00
|
|
|
static inline void free_list_of_pages(struct linked_page *list,
|
|
|
|
int clear_page_nosave)
|
2006-09-26 14:32:54 +08:00
|
|
|
{
|
|
|
|
while (list) {
|
|
|
|
struct linked_page *lp = list->next;
|
|
|
|
|
|
|
|
free_image_page(list, clear_page_nosave);
|
|
|
|
list = lp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2006-09-26 14:32:54 +08:00
|
|
|
struct chain_allocator {
|
|
|
|
struct linked_page *chain; /* the chain */
|
|
|
|
unsigned int used_space; /* total size of objects allocated out
|
2016-07-07 05:43:46 +08:00
|
|
|
of the current page */
|
2006-09-26 14:32:54 +08:00
|
|
|
gfp_t gfp_mask; /* mask for allocating pages */
|
|
|
|
int safe_needed; /* if set, only "safe" pages are allocated */
|
|
|
|
};
|
|
|
|
|
2016-07-07 05:42:46 +08:00
|
|
|
static void chain_init(struct chain_allocator *ca, gfp_t gfp_mask,
|
|
|
|
int safe_needed)
|
2006-09-26 14:32:54 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2016-06-29 09:00:51 +08:00
|
|
|
lp = ca->safe_needed ? __get_safe_page(ca->gfp_mask) :
|
|
|
|
get_image_page(ca->gfp_mask, PG_ANY);
|
2006-09-26 14:32:54 +08: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;
|
|
|
|
}
|
|
|
|
|
2022-04-01 18:01:34 +08:00
|
|
|
/*
|
2016-07-07 05:43:46 +08:00
|
|
|
* Data types related to memory bitmaps.
|
2006-09-26 14:32:54 +08:00
|
|
|
*
|
2021-04-08 16:14:44 +08:00
|
|
|
* Memory bitmap is a structure consisting of many linked lists of
|
2016-07-07 05:43:46 +08:00
|
|
|
* objects. The main list's elements are of type struct zone_bitmap
|
2021-05-24 17:30:10 +08:00
|
|
|
* and each of them corresponds to one zone. For each zone bitmap
|
2016-07-07 05:43:46 +08:00
|
|
|
* object there is a list of objects of type struct bm_block that
|
|
|
|
* represent each blocks of bitmap in which information is stored.
|
2006-09-26 14:32:54 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08: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.
|
2006-09-26 14:32:54 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* 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 ;-).
|
2006-09-26 14:32:54 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* 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.
|
2006-09-26 14:32:54 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* struct bm_block contains a pointer to the memory page in which
|
|
|
|
* 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.
|
2014-07-21 18:26:57 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* The memory bitmap is organized as a radix tree to guarantee fast random
|
|
|
|
* access to the bits. There is one radix tree for each zone (as returned
|
|
|
|
* from create_mem_extents).
|
2014-07-21 18:26:57 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* One radix tree is represented by one struct mem_zone_bm_rtree. There are
|
|
|
|
* two linked lists for the nodes of the tree, one for the inner nodes and
|
|
|
|
* one for the leave nodes. The linked leave nodes are used for fast linear
|
|
|
|
* access of the memory bitmap.
|
2014-07-21 18:26:57 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* The struct rtree_node represents one node of the radix tree.
|
2006-09-26 14:32:54 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
#define BM_END_OF_MAP (~0UL)
|
|
|
|
|
2009-07-23 01:56:10 +08:00
|
|
|
#define BM_BITS_PER_BLOCK (PAGE_SIZE * BITS_PER_BYTE)
|
2014-07-21 18:26:57 +08:00
|
|
|
#define BM_BLOCK_SHIFT (PAGE_SHIFT + 3)
|
|
|
|
#define BM_BLOCK_MASK ((1UL << BM_BLOCK_SHIFT) - 1)
|
2006-09-26 14:32:54 +08:00
|
|
|
|
2014-07-21 18:26:57 +08:00
|
|
|
/*
|
|
|
|
* struct rtree_node is a wrapper struct to link the nodes
|
|
|
|
* of the rtree together for easy linear iteration over
|
|
|
|
* bits and easy freeing
|
|
|
|
*/
|
|
|
|
struct rtree_node {
|
|
|
|
struct list_head list;
|
|
|
|
unsigned long *data;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* struct mem_zone_bm_rtree represents a bitmap used for one
|
|
|
|
* populated memory zone.
|
|
|
|
*/
|
|
|
|
struct mem_zone_bm_rtree {
|
|
|
|
struct list_head list; /* Link Zones together */
|
|
|
|
struct list_head nodes; /* Radix Tree inner nodes */
|
|
|
|
struct list_head leaves; /* Radix Tree leaves */
|
|
|
|
unsigned long start_pfn; /* Zone start page frame */
|
|
|
|
unsigned long end_pfn; /* Zone end page frame + 1 */
|
|
|
|
struct rtree_node *rtree; /* Radix Tree Root */
|
|
|
|
int levels; /* Number of Radix Tree Levels */
|
|
|
|
unsigned int blocks; /* Number of Bitmap Blocks */
|
|
|
|
};
|
|
|
|
|
2023-05-04 17:18:24 +08:00
|
|
|
/* struct bm_position is used for browsing memory bitmaps */
|
2006-09-26 14:32:54 +08:00
|
|
|
|
|
|
|
struct bm_position {
|
2014-07-21 18:26:59 +08:00
|
|
|
struct mem_zone_bm_rtree *zone;
|
|
|
|
struct rtree_node *node;
|
|
|
|
unsigned long node_pfn;
|
2023-07-15 01:55:05 +08:00
|
|
|
unsigned long cur_pfn;
|
2014-07-21 18:26:59 +08:00
|
|
|
int node_bit;
|
2006-09-26 14:32:54 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct memory_bitmap {
|
2014-07-21 18:26:57 +08:00
|
|
|
struct list_head zones;
|
2006-09-26 14:32:54 +08:00
|
|
|
struct linked_page *p_list; /* list of pages used to store zone
|
2016-07-07 05:43:46 +08:00
|
|
|
bitmap objects and bitmap block
|
|
|
|
objects */
|
2006-09-26 14:32:54 +08:00
|
|
|
struct bm_position cur; /* most recently used bit position */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Functions that operate on memory bitmaps */
|
|
|
|
|
2014-07-21 18:26:57 +08:00
|
|
|
#define BM_ENTRIES_PER_LEVEL (PAGE_SIZE / sizeof(unsigned long))
|
|
|
|
#if BITS_PER_LONG == 32
|
|
|
|
#define BM_RTREE_LEVEL_SHIFT (PAGE_SHIFT - 2)
|
|
|
|
#else
|
|
|
|
#define BM_RTREE_LEVEL_SHIFT (PAGE_SHIFT - 3)
|
|
|
|
#endif
|
|
|
|
#define BM_RTREE_LEVEL_MASK ((1UL << BM_RTREE_LEVEL_SHIFT) - 1)
|
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/**
|
|
|
|
* alloc_rtree_node - Allocate a new node and add it to the radix tree.
|
2022-03-25 09:44:15 +08:00
|
|
|
* @gfp_mask: GFP mask for the allocation.
|
|
|
|
* @safe_needed: Get pages not used before hibernation (restore only)
|
|
|
|
* @ca: Pointer to a linked list of pages ("a chain") to allocate from
|
|
|
|
* @list: Radix Tree node to add.
|
2014-07-21 18:26:57 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* This function is used to allocate inner nodes as well as the
|
|
|
|
* leave nodes of the radix tree. It also adds the node to the
|
|
|
|
* corresponding linked list passed in by the *list parameter.
|
2014-07-21 18:26:57 +08:00
|
|
|
*/
|
|
|
|
static struct rtree_node *alloc_rtree_node(gfp_t gfp_mask, int safe_needed,
|
|
|
|
struct chain_allocator *ca,
|
|
|
|
struct list_head *list)
|
|
|
|
{
|
|
|
|
struct rtree_node *node;
|
|
|
|
|
|
|
|
node = chain_alloc(ca, sizeof(struct rtree_node));
|
|
|
|
if (!node)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
node->data = get_image_page(gfp_mask, safe_needed);
|
|
|
|
if (!node->data)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
list_add_tail(&node->list, list);
|
|
|
|
|
|
|
|
return node;
|
|
|
|
}
|
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/**
|
|
|
|
* add_rtree_block - Add a new leave node to the radix tree.
|
2014-07-21 18:26:57 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* The leave nodes need to be allocated in order to keep the leaves
|
|
|
|
* linked list in order. This is guaranteed by the zone->blocks
|
|
|
|
* counter.
|
2014-07-21 18:26:57 +08:00
|
|
|
*/
|
|
|
|
static int add_rtree_block(struct mem_zone_bm_rtree *zone, gfp_t gfp_mask,
|
|
|
|
int safe_needed, struct chain_allocator *ca)
|
|
|
|
{
|
|
|
|
struct rtree_node *node, *block, **dst;
|
|
|
|
unsigned int levels_needed, block_nr;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
block_nr = zone->blocks;
|
|
|
|
levels_needed = 0;
|
|
|
|
|
|
|
|
/* How many levels do we need for this block nr? */
|
|
|
|
while (block_nr) {
|
|
|
|
levels_needed += 1;
|
|
|
|
block_nr >>= BM_RTREE_LEVEL_SHIFT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure the rtree has enough levels */
|
|
|
|
for (i = zone->levels; i < levels_needed; i++) {
|
|
|
|
node = alloc_rtree_node(gfp_mask, safe_needed, ca,
|
|
|
|
&zone->nodes);
|
|
|
|
if (!node)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
node->data[0] = (unsigned long)zone->rtree;
|
|
|
|
zone->rtree = node;
|
|
|
|
zone->levels += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate new block */
|
|
|
|
block = alloc_rtree_node(gfp_mask, safe_needed, ca, &zone->leaves);
|
|
|
|
if (!block)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* Now walk the rtree to insert the block */
|
|
|
|
node = zone->rtree;
|
|
|
|
dst = &zone->rtree;
|
|
|
|
block_nr = zone->blocks;
|
|
|
|
for (i = zone->levels; i > 0; i--) {
|
|
|
|
int index;
|
|
|
|
|
|
|
|
if (!node) {
|
|
|
|
node = alloc_rtree_node(gfp_mask, safe_needed, ca,
|
|
|
|
&zone->nodes);
|
|
|
|
if (!node)
|
|
|
|
return -ENOMEM;
|
|
|
|
*dst = node;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = block_nr >> ((i - 1) * BM_RTREE_LEVEL_SHIFT);
|
|
|
|
index &= BM_RTREE_LEVEL_MASK;
|
|
|
|
dst = (struct rtree_node **)&((*dst)->data[index]);
|
|
|
|
node = *dst;
|
|
|
|
}
|
|
|
|
|
|
|
|
zone->blocks += 1;
|
|
|
|
*dst = block;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_zone_bm_rtree(struct mem_zone_bm_rtree *zone,
|
|
|
|
int clear_nosave_free);
|
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/**
|
|
|
|
* create_zone_bm_rtree - Create a radix tree for one zone.
|
2014-07-21 18:26:57 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* Allocated the mem_zone_bm_rtree structure and initializes it.
|
|
|
|
* This function also allocated and builds the radix tree for the
|
|
|
|
* zone.
|
2014-07-21 18:26:57 +08:00
|
|
|
*/
|
2016-07-07 05:42:46 +08:00
|
|
|
static struct mem_zone_bm_rtree *create_zone_bm_rtree(gfp_t gfp_mask,
|
|
|
|
int safe_needed,
|
|
|
|
struct chain_allocator *ca,
|
|
|
|
unsigned long start,
|
|
|
|
unsigned long end)
|
2014-07-21 18:26:57 +08:00
|
|
|
{
|
|
|
|
struct mem_zone_bm_rtree *zone;
|
|
|
|
unsigned int i, nr_blocks;
|
|
|
|
unsigned long pages;
|
|
|
|
|
|
|
|
pages = end - start;
|
|
|
|
zone = chain_alloc(ca, sizeof(struct mem_zone_bm_rtree));
|
|
|
|
if (!zone)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&zone->nodes);
|
|
|
|
INIT_LIST_HEAD(&zone->leaves);
|
|
|
|
zone->start_pfn = start;
|
|
|
|
zone->end_pfn = end;
|
|
|
|
nr_blocks = DIV_ROUND_UP(pages, BM_BITS_PER_BLOCK);
|
|
|
|
|
|
|
|
for (i = 0; i < nr_blocks; i++) {
|
|
|
|
if (add_rtree_block(zone, gfp_mask, safe_needed, ca)) {
|
|
|
|
free_zone_bm_rtree(zone, PG_UNSAFE_CLEAR);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return zone;
|
|
|
|
}
|
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/**
|
|
|
|
* free_zone_bm_rtree - Free the memory of the radix tree.
|
2014-07-21 18:26:57 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* Free all node pages of the radix tree. The mem_zone_bm_rtree
|
|
|
|
* structure itself is not freed here nor are the rtree_node
|
|
|
|
* structs.
|
2014-07-21 18:26:57 +08:00
|
|
|
*/
|
|
|
|
static void free_zone_bm_rtree(struct mem_zone_bm_rtree *zone,
|
|
|
|
int clear_nosave_free)
|
|
|
|
{
|
|
|
|
struct rtree_node *node;
|
|
|
|
|
|
|
|
list_for_each_entry(node, &zone->nodes, list)
|
|
|
|
free_image_page(node->data, clear_nosave_free);
|
|
|
|
|
|
|
|
list_for_each_entry(node, &zone->leaves, list)
|
|
|
|
free_image_page(node->data, clear_nosave_free);
|
|
|
|
}
|
|
|
|
|
2006-09-26 14:32:54 +08:00
|
|
|
static void memory_bm_position_reset(struct memory_bitmap *bm)
|
|
|
|
{
|
2014-07-21 18:26:59 +08:00
|
|
|
bm->cur.zone = list_entry(bm->zones.next, struct mem_zone_bm_rtree,
|
|
|
|
list);
|
|
|
|
bm->cur.node = list_entry(bm->cur.zone->leaves.next,
|
|
|
|
struct rtree_node, list);
|
|
|
|
bm->cur.node_pfn = 0;
|
2023-07-15 01:55:05 +08:00
|
|
|
bm->cur.cur_pfn = BM_END_OF_MAP;
|
2014-07-21 18:26:59 +08:00
|
|
|
bm->cur.node_bit = 0;
|
2006-09-26 14:32:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void memory_bm_free(struct memory_bitmap *bm, int clear_nosave_free);
|
|
|
|
|
2008-11-27 07:00:24 +08:00
|
|
|
struct mem_extent {
|
|
|
|
struct list_head hook;
|
|
|
|
unsigned long start;
|
|
|
|
unsigned long end;
|
|
|
|
};
|
|
|
|
|
2006-09-26 14:32:54 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* free_mem_extents - Free a list of memory extents.
|
|
|
|
* @list: List of extents to free.
|
2006-09-26 14:32:54 +08:00
|
|
|
*/
|
2008-11-27 07:00:24 +08:00
|
|
|
static void free_mem_extents(struct list_head *list)
|
|
|
|
{
|
|
|
|
struct mem_extent *ext, *aux;
|
2006-09-26 14:32:54 +08:00
|
|
|
|
2008-11-27 07:00:24 +08:00
|
|
|
list_for_each_entry_safe(ext, aux, list, hook) {
|
|
|
|
list_del(&ext->hook);
|
|
|
|
kfree(ext);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* create_mem_extents - Create a list of memory extents.
|
|
|
|
* @list: List to put the extents into.
|
|
|
|
* @gfp_mask: Mask to use for memory allocations.
|
|
|
|
*
|
|
|
|
* The extents represent contiguous ranges of PFNs.
|
2008-11-27 07:00:24 +08:00
|
|
|
*/
|
|
|
|
static int create_mem_extents(struct list_head *list, gfp_t gfp_mask)
|
2006-09-26 14:32:54 +08:00
|
|
|
{
|
2008-11-27 07:00:24 +08:00
|
|
|
struct zone *zone;
|
2006-09-26 14:32:54 +08:00
|
|
|
|
2008-11-27 07:00:24 +08:00
|
|
|
INIT_LIST_HEAD(list);
|
2006-09-26 14:32:54 +08:00
|
|
|
|
2009-04-01 06:19:31 +08:00
|
|
|
for_each_populated_zone(zone) {
|
2008-11-27 07:00:24 +08:00
|
|
|
unsigned long zone_start, zone_end;
|
|
|
|
struct mem_extent *ext, *cur, *aux;
|
|
|
|
|
|
|
|
zone_start = zone->zone_start_pfn;
|
2013-09-12 05:21:44 +08:00
|
|
|
zone_end = zone_end_pfn(zone);
|
2008-11-27 07:00:24 +08:00
|
|
|
|
|
|
|
list_for_each_entry(ext, list, hook)
|
|
|
|
if (zone_start <= ext->end)
|
|
|
|
break;
|
2006-09-26 14:32:54 +08:00
|
|
|
|
2008-11-27 07:00:24 +08: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 14:32:54 +08:00
|
|
|
}
|
2008-11-27 07:00:24 +08:00
|
|
|
|
|
|
|
return 0;
|
2006-09-26 14:32:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* memory_bm_create - Allocate memory for a memory bitmap.
|
|
|
|
*/
|
2016-07-07 05:42:46 +08:00
|
|
|
static int memory_bm_create(struct memory_bitmap *bm, gfp_t gfp_mask,
|
|
|
|
int safe_needed)
|
2006-09-26 14:32:54 +08:00
|
|
|
{
|
|
|
|
struct chain_allocator ca;
|
2008-11-27 07:00:24 +08:00
|
|
|
struct list_head mem_extents;
|
|
|
|
struct mem_extent *ext;
|
|
|
|
int error;
|
2006-09-26 14:32:54 +08:00
|
|
|
|
|
|
|
chain_init(&ca, gfp_mask, safe_needed);
|
2014-07-21 18:26:57 +08:00
|
|
|
INIT_LIST_HEAD(&bm->zones);
|
2006-09-26 14:32:54 +08:00
|
|
|
|
2008-11-27 07:00:24 +08:00
|
|
|
error = create_mem_extents(&mem_extents, gfp_mask);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2006-09-26 14:32:54 +08:00
|
|
|
|
2008-11-27 07:00:24 +08:00
|
|
|
list_for_each_entry(ext, &mem_extents, hook) {
|
2014-07-21 18:26:57 +08:00
|
|
|
struct mem_zone_bm_rtree *zone;
|
|
|
|
|
|
|
|
zone = create_zone_bm_rtree(gfp_mask, safe_needed, &ca,
|
|
|
|
ext->start, ext->end);
|
2014-07-21 18:27:01 +08:00
|
|
|
if (!zone) {
|
|
|
|
error = -ENOMEM;
|
2014-07-21 18:26:57 +08:00
|
|
|
goto Error;
|
2014-07-21 18:27:01 +08:00
|
|
|
}
|
2014-07-21 18:26:57 +08:00
|
|
|
list_add_tail(&zone->list, &bm->zones);
|
2006-09-26 14:32:54 +08:00
|
|
|
}
|
2008-11-27 07:00:24 +08:00
|
|
|
|
2006-09-26 14:32:54 +08:00
|
|
|
bm->p_list = ca.chain;
|
|
|
|
memory_bm_position_reset(bm);
|
2008-11-27 07:00:24 +08:00
|
|
|
Exit:
|
|
|
|
free_mem_extents(&mem_extents);
|
|
|
|
return error;
|
2006-09-26 14:32:54 +08:00
|
|
|
|
2008-11-27 07:00:24 +08:00
|
|
|
Error:
|
2006-09-26 14:32:54 +08:00
|
|
|
bm->p_list = ca.chain;
|
|
|
|
memory_bm_free(bm, PG_UNSAFE_CLEAR);
|
2008-11-27 07:00:24 +08:00
|
|
|
goto Exit;
|
2006-09-26 14:32:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* memory_bm_free - Free memory occupied by the memory bitmap.
|
|
|
|
* @bm: Memory bitmap.
|
|
|
|
*/
|
2006-09-26 14:32:54 +08:00
|
|
|
static void memory_bm_free(struct memory_bitmap *bm, int clear_nosave_free)
|
|
|
|
{
|
2014-07-21 18:26:57 +08:00
|
|
|
struct mem_zone_bm_rtree *zone;
|
2006-09-26 14:32:54 +08:00
|
|
|
|
2014-07-21 18:26:57 +08:00
|
|
|
list_for_each_entry(zone, &bm->zones, list)
|
|
|
|
free_zone_bm_rtree(zone, clear_nosave_free);
|
|
|
|
|
2006-09-26 14:32:54 +08:00
|
|
|
free_list_of_pages(bm->p_list, clear_nosave_free);
|
2008-11-27 07:00:24 +08:00
|
|
|
|
2014-07-21 18:26:57 +08:00
|
|
|
INIT_LIST_HEAD(&bm->zones);
|
2006-09-26 14:32:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* memory_bm_find_bit - Find the bit for a given PFN in a memory bitmap.
|
2014-07-21 18:26:58 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* Find the bit in memory bitmap @bm that corresponds to the given PFN.
|
|
|
|
* The cur.zone, cur.block and cur.node_pfn members of @bm are updated.
|
|
|
|
*
|
|
|
|
* Walk the radix tree to find the page containing the bit that represents @pfn
|
|
|
|
* and return the position of the bit in @addr and @bit_nr.
|
2014-07-21 18:26:58 +08:00
|
|
|
*/
|
2014-07-21 18:27:01 +08:00
|
|
|
static int memory_bm_find_bit(struct memory_bitmap *bm, unsigned long pfn,
|
|
|
|
void **addr, unsigned int *bit_nr)
|
2014-07-21 18:26:58 +08:00
|
|
|
{
|
|
|
|
struct mem_zone_bm_rtree *curr, *zone;
|
|
|
|
struct rtree_node *node;
|
|
|
|
int i, block_nr;
|
|
|
|
|
2014-07-21 18:26:59 +08:00
|
|
|
zone = bm->cur.zone;
|
|
|
|
|
|
|
|
if (pfn >= zone->start_pfn && pfn < zone->end_pfn)
|
|
|
|
goto zone_found;
|
|
|
|
|
2014-07-21 18:26:58 +08:00
|
|
|
zone = NULL;
|
|
|
|
|
|
|
|
/* Find the right zone */
|
|
|
|
list_for_each_entry(curr, &bm->zones, list) {
|
|
|
|
if (pfn >= curr->start_pfn && pfn < curr->end_pfn) {
|
|
|
|
zone = curr;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!zone)
|
|
|
|
return -EFAULT;
|
|
|
|
|
2014-07-21 18:26:59 +08:00
|
|
|
zone_found:
|
2014-07-21 18:26:58 +08:00
|
|
|
/*
|
2016-07-07 05:43:46 +08:00
|
|
|
* We have found the zone. Now walk the radix tree to find the leaf node
|
|
|
|
* for our PFN.
|
2014-07-21 18:26:58 +08:00
|
|
|
*/
|
2019-09-25 22:39:12 +08:00
|
|
|
|
|
|
|
/*
|
2020-10-16 11:10:28 +08:00
|
|
|
* If the zone we wish to scan is the current zone and the
|
2019-09-25 22:39:12 +08:00
|
|
|
* pfn falls into the current node then we do not need to walk
|
|
|
|
* the tree.
|
|
|
|
*/
|
2014-07-21 18:26:59 +08:00
|
|
|
node = bm->cur.node;
|
2019-09-25 22:39:12 +08:00
|
|
|
if (zone == bm->cur.zone &&
|
|
|
|
((pfn - zone->start_pfn) & ~BM_BLOCK_MASK) == bm->cur.node_pfn)
|
2014-07-21 18:26:59 +08:00
|
|
|
goto node_found;
|
|
|
|
|
2014-07-21 18:26:58 +08:00
|
|
|
node = zone->rtree;
|
|
|
|
block_nr = (pfn - zone->start_pfn) >> BM_BLOCK_SHIFT;
|
|
|
|
|
|
|
|
for (i = zone->levels; i > 0; i--) {
|
|
|
|
int index;
|
|
|
|
|
|
|
|
index = block_nr >> ((i - 1) * BM_RTREE_LEVEL_SHIFT);
|
|
|
|
index &= BM_RTREE_LEVEL_MASK;
|
|
|
|
BUG_ON(node->data[index] == 0);
|
|
|
|
node = (struct rtree_node *)node->data[index];
|
|
|
|
}
|
|
|
|
|
2014-07-21 18:26:59 +08:00
|
|
|
node_found:
|
|
|
|
/* Update last position */
|
|
|
|
bm->cur.zone = zone;
|
|
|
|
bm->cur.node = node;
|
|
|
|
bm->cur.node_pfn = (pfn - zone->start_pfn) & ~BM_BLOCK_MASK;
|
2023-07-15 01:55:05 +08:00
|
|
|
bm->cur.cur_pfn = pfn;
|
2014-07-21 18:26:59 +08:00
|
|
|
|
2014-07-21 18:26:58 +08:00
|
|
|
/* Set return values */
|
|
|
|
*addr = node->data;
|
|
|
|
*bit_nr = (pfn - zone->start_pfn) & BM_BLOCK_MASK;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-05-07 05:50:43 +08:00
|
|
|
static void memory_bm_set_bit(struct memory_bitmap *bm, unsigned long pfn)
|
|
|
|
{
|
|
|
|
void *addr;
|
|
|
|
unsigned int bit;
|
2008-03-12 07:34:57 +08:00
|
|
|
int error;
|
2007-05-07 05:50:43 +08:00
|
|
|
|
2008-03-12 07:34:57 +08:00
|
|
|
error = memory_bm_find_bit(bm, pfn, &addr, &bit);
|
|
|
|
BUG_ON(error);
|
2007-05-07 05:50:43 +08:00
|
|
|
set_bit(bit, addr);
|
|
|
|
}
|
|
|
|
|
2008-03-12 07:34:57 +08: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);
|
2014-07-21 18:26:58 +08:00
|
|
|
if (!error)
|
|
|
|
set_bit(bit, addr);
|
|
|
|
|
2008-03-12 07:34:57 +08:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-05-07 05:50:43 +08:00
|
|
|
static void memory_bm_clear_bit(struct memory_bitmap *bm, unsigned long pfn)
|
|
|
|
{
|
|
|
|
void *addr;
|
|
|
|
unsigned int bit;
|
2008-03-12 07:34:57 +08:00
|
|
|
int error;
|
2007-05-07 05:50:43 +08:00
|
|
|
|
2008-03-12 07:34:57 +08:00
|
|
|
error = memory_bm_find_bit(bm, pfn, &addr, &bit);
|
|
|
|
BUG_ON(error);
|
2007-05-07 05:50:43 +08:00
|
|
|
clear_bit(bit, addr);
|
|
|
|
}
|
|
|
|
|
2014-09-30 19:31:29 +08:00
|
|
|
static void memory_bm_clear_current(struct memory_bitmap *bm)
|
|
|
|
{
|
|
|
|
int bit;
|
|
|
|
|
|
|
|
bit = max(bm->cur.node_bit - 1, 0);
|
|
|
|
clear_bit(bit, bm->cur.node->data);
|
|
|
|
}
|
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
static unsigned long memory_bm_get_current(struct memory_bitmap *bm)
|
|
|
|
{
|
|
|
|
return bm->cur.cur_pfn;
|
|
|
|
}
|
|
|
|
|
2007-05-07 05:50:43 +08:00
|
|
|
static int memory_bm_test_bit(struct memory_bitmap *bm, unsigned long pfn)
|
|
|
|
{
|
|
|
|
void *addr;
|
|
|
|
unsigned int bit;
|
2014-07-21 18:27:01 +08:00
|
|
|
int error;
|
2007-05-07 05:50:43 +08:00
|
|
|
|
2008-03-12 07:34:57 +08:00
|
|
|
error = memory_bm_find_bit(bm, pfn, &addr, &bit);
|
|
|
|
BUG_ON(error);
|
2014-07-21 18:27:01 +08:00
|
|
|
return test_bit(bit, addr);
|
2006-09-26 14:32:54 +08:00
|
|
|
}
|
|
|
|
|
2008-11-12 04:32:44 +08:00
|
|
|
static bool memory_bm_pfn_present(struct memory_bitmap *bm, unsigned long pfn)
|
|
|
|
{
|
|
|
|
void *addr;
|
|
|
|
unsigned int bit;
|
2014-07-21 18:26:58 +08:00
|
|
|
|
2014-07-21 18:27:01 +08:00
|
|
|
return !memory_bm_find_bit(bm, pfn, &addr, &bit);
|
2006-09-26 14:32:54 +08:00
|
|
|
}
|
|
|
|
|
2014-07-21 18:26:59 +08:00
|
|
|
/*
|
2016-07-07 05:43:46 +08:00
|
|
|
* rtree_next_node - Jump to the next leaf node.
|
2014-07-21 18:26:59 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* Set the position to the beginning of the next node in the
|
|
|
|
* memory bitmap. This is either the next node in the current
|
|
|
|
* zone's radix tree or the first node in the radix tree of the
|
|
|
|
* next zone.
|
2014-07-21 18:26:59 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* Return true if there is a next node, false otherwise.
|
2014-07-21 18:26:59 +08:00
|
|
|
*/
|
|
|
|
static bool rtree_next_node(struct memory_bitmap *bm)
|
|
|
|
{
|
PM / hibernate: Fix rtree_next_node() to avoid walking off list ends
rtree_next_node() walks the linked list of leaf nodes to find the next
block of pages in the struct memory_bitmap. If it walks off the end of
the list of nodes, it walks the list of memory zones to find the next
region of memory. If it walks off the end of the list of zones, it
returns false.
This leaves the struct bm_position's node and zone pointers pointing
at their respective struct list_heads in struct mem_zone_bm_rtree.
memory_bm_find_bit() uses struct bm_position's node and zone pointers
to avoid walking lists and trees if the next bit appears in the same
node/zone. It handles these values being stale.
Swap rtree_next_node()s 'step then test' to 'test-next then step',
this means if we reach the end of memory we return false and leave
the node and zone pointers as they were.
This fixes a panic on resume using AMD Seattle with 64K pages:
[ 6.868732] Freezing user space processes ... (elapsed 0.000 seconds) done.
[ 6.875753] Double checking all user space processes after OOM killer disable... (elapsed 0.000 seconds)
[ 6.896453] PM: Using 3 thread(s) for decompression.
[ 6.896453] PM: Loading and decompressing image data (5339 pages)...
[ 7.318890] PM: Image loading progress: 0%
[ 7.323395] Unable to handle kernel paging request at virtual address 00800040
[ 7.330611] pgd = ffff000008df0000
[ 7.334003] [00800040] *pgd=00000083fffe0003, *pud=00000083fffe0003, *pmd=00000083fffd0003, *pte=0000000000000000
[ 7.344266] Internal error: Oops: 96000005 [#1] PREEMPT SMP
[ 7.349825] Modules linked in:
[ 7.352871] CPU: 2 PID: 1 Comm: swapper/0 Tainted: G W I 4.8.0-rc1 #4737
[ 7.360512] Hardware name: AMD Overdrive/Supercharger/Default string, BIOS ROD1002C 04/08/2016
[ 7.369109] task: ffff8003c0220000 task.stack: ffff8003c0280000
[ 7.375020] PC is at set_bit+0x18/0x30
[ 7.378758] LR is at memory_bm_set_bit+0x24/0x30
[ 7.383362] pc : [<ffff00000835bbc8>] lr : [<ffff0000080faf18>] pstate: 60000045
[ 7.390743] sp : ffff8003c0283b00
[ 7.473551]
[ 7.475031] Process swapper/0 (pid: 1, stack limit = 0xffff8003c0280020)
[ 7.481718] Stack: (0xffff8003c0283b00 to 0xffff8003c0284000)
[ 7.800075] Call trace:
[ 7.887097] [<ffff00000835bbc8>] set_bit+0x18/0x30
[ 7.891876] [<ffff0000080fb038>] duplicate_memory_bitmap.constprop.38+0x54/0x70
[ 7.899172] [<ffff0000080fcc40>] snapshot_write_next+0x22c/0x47c
[ 7.905166] [<ffff0000080fe1b4>] load_image_lzo+0x754/0xa88
[ 7.910725] [<ffff0000080ff0a8>] swsusp_read+0x144/0x230
[ 7.916025] [<ffff0000080fa338>] load_image_and_restore+0x58/0x90
[ 7.922105] [<ffff0000080fa660>] software_resume+0x2f0/0x338
[ 7.927752] [<ffff000008083350>] do_one_initcall+0x38/0x11c
[ 7.933314] [<ffff000008b40cc0>] kernel_init_freeable+0x14c/0x1ec
[ 7.939395] [<ffff0000087ce564>] kernel_init+0x10/0xfc
[ 7.944520] [<ffff000008082e90>] ret_from_fork+0x10/0x40
[ 7.949820] Code: d2800022 8b400c21 f9800031 9ac32043 (c85f7c22)
[ 7.955909] ---[ end trace 0024a5986e6ff323 ]---
[ 7.960529] Kernel panic - not syncing: Attempted to kill init! exitcode=0x0000000b
Here struct mem_zone_bm_rtree's start_pfn has been returned instead of
struct rtree_node's addr as the node/zone pointers are corrupt after
we walked off the end of the lists during mark_unsafe_pages().
This behaviour was exposed by commit 6dbecfd345a6 ("PM / hibernate:
Simplify mark_unsafe_pages()"), which caused mark_unsafe_pages() to call
duplicate_memory_bitmap(), which uses memory_bm_find_bit() after walking
off the end of the memory bitmap.
Fixes: 3a20cb177961 (PM / Hibernate: Implement position keeping in radix tree)
Signed-off-by: James Morse <james.morse@arm.com>
[ rjw: Subject ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2016-08-16 17:46:38 +08:00
|
|
|
if (!list_is_last(&bm->cur.node->list, &bm->cur.zone->leaves)) {
|
|
|
|
bm->cur.node = list_entry(bm->cur.node->list.next,
|
|
|
|
struct rtree_node, list);
|
2014-07-21 18:26:59 +08:00
|
|
|
bm->cur.node_pfn += BM_BITS_PER_BLOCK;
|
|
|
|
bm->cur.node_bit = 0;
|
2014-07-21 18:27:02 +08:00
|
|
|
touch_softlockup_watchdog();
|
2014-07-21 18:26:59 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No more nodes, goto next zone */
|
PM / hibernate: Fix rtree_next_node() to avoid walking off list ends
rtree_next_node() walks the linked list of leaf nodes to find the next
block of pages in the struct memory_bitmap. If it walks off the end of
the list of nodes, it walks the list of memory zones to find the next
region of memory. If it walks off the end of the list of zones, it
returns false.
This leaves the struct bm_position's node and zone pointers pointing
at their respective struct list_heads in struct mem_zone_bm_rtree.
memory_bm_find_bit() uses struct bm_position's node and zone pointers
to avoid walking lists and trees if the next bit appears in the same
node/zone. It handles these values being stale.
Swap rtree_next_node()s 'step then test' to 'test-next then step',
this means if we reach the end of memory we return false and leave
the node and zone pointers as they were.
This fixes a panic on resume using AMD Seattle with 64K pages:
[ 6.868732] Freezing user space processes ... (elapsed 0.000 seconds) done.
[ 6.875753] Double checking all user space processes after OOM killer disable... (elapsed 0.000 seconds)
[ 6.896453] PM: Using 3 thread(s) for decompression.
[ 6.896453] PM: Loading and decompressing image data (5339 pages)...
[ 7.318890] PM: Image loading progress: 0%
[ 7.323395] Unable to handle kernel paging request at virtual address 00800040
[ 7.330611] pgd = ffff000008df0000
[ 7.334003] [00800040] *pgd=00000083fffe0003, *pud=00000083fffe0003, *pmd=00000083fffd0003, *pte=0000000000000000
[ 7.344266] Internal error: Oops: 96000005 [#1] PREEMPT SMP
[ 7.349825] Modules linked in:
[ 7.352871] CPU: 2 PID: 1 Comm: swapper/0 Tainted: G W I 4.8.0-rc1 #4737
[ 7.360512] Hardware name: AMD Overdrive/Supercharger/Default string, BIOS ROD1002C 04/08/2016
[ 7.369109] task: ffff8003c0220000 task.stack: ffff8003c0280000
[ 7.375020] PC is at set_bit+0x18/0x30
[ 7.378758] LR is at memory_bm_set_bit+0x24/0x30
[ 7.383362] pc : [<ffff00000835bbc8>] lr : [<ffff0000080faf18>] pstate: 60000045
[ 7.390743] sp : ffff8003c0283b00
[ 7.473551]
[ 7.475031] Process swapper/0 (pid: 1, stack limit = 0xffff8003c0280020)
[ 7.481718] Stack: (0xffff8003c0283b00 to 0xffff8003c0284000)
[ 7.800075] Call trace:
[ 7.887097] [<ffff00000835bbc8>] set_bit+0x18/0x30
[ 7.891876] [<ffff0000080fb038>] duplicate_memory_bitmap.constprop.38+0x54/0x70
[ 7.899172] [<ffff0000080fcc40>] snapshot_write_next+0x22c/0x47c
[ 7.905166] [<ffff0000080fe1b4>] load_image_lzo+0x754/0xa88
[ 7.910725] [<ffff0000080ff0a8>] swsusp_read+0x144/0x230
[ 7.916025] [<ffff0000080fa338>] load_image_and_restore+0x58/0x90
[ 7.922105] [<ffff0000080fa660>] software_resume+0x2f0/0x338
[ 7.927752] [<ffff000008083350>] do_one_initcall+0x38/0x11c
[ 7.933314] [<ffff000008b40cc0>] kernel_init_freeable+0x14c/0x1ec
[ 7.939395] [<ffff0000087ce564>] kernel_init+0x10/0xfc
[ 7.944520] [<ffff000008082e90>] ret_from_fork+0x10/0x40
[ 7.949820] Code: d2800022 8b400c21 f9800031 9ac32043 (c85f7c22)
[ 7.955909] ---[ end trace 0024a5986e6ff323 ]---
[ 7.960529] Kernel panic - not syncing: Attempted to kill init! exitcode=0x0000000b
Here struct mem_zone_bm_rtree's start_pfn has been returned instead of
struct rtree_node's addr as the node/zone pointers are corrupt after
we walked off the end of the lists during mark_unsafe_pages().
This behaviour was exposed by commit 6dbecfd345a6 ("PM / hibernate:
Simplify mark_unsafe_pages()"), which caused mark_unsafe_pages() to call
duplicate_memory_bitmap(), which uses memory_bm_find_bit() after walking
off the end of the memory bitmap.
Fixes: 3a20cb177961 (PM / Hibernate: Implement position keeping in radix tree)
Signed-off-by: James Morse <james.morse@arm.com>
[ rjw: Subject ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2016-08-16 17:46:38 +08:00
|
|
|
if (!list_is_last(&bm->cur.zone->list, &bm->zones)) {
|
|
|
|
bm->cur.zone = list_entry(bm->cur.zone->list.next,
|
2014-07-21 18:26:59 +08:00
|
|
|
struct mem_zone_bm_rtree, list);
|
|
|
|
bm->cur.node = list_entry(bm->cur.zone->leaves.next,
|
|
|
|
struct rtree_node, list);
|
|
|
|
bm->cur.node_pfn = 0;
|
|
|
|
bm->cur.node_bit = 0;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No more zones */
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-07-21 18:27:01 +08:00
|
|
|
/**
|
2022-03-25 09:44:15 +08:00
|
|
|
* memory_bm_next_pfn - Find the next set bit in a memory bitmap.
|
2016-07-07 05:43:46 +08:00
|
|
|
* @bm: Memory bitmap.
|
2014-07-21 18:26:59 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* Starting from the last returned position this function searches for the next
|
|
|
|
* set bit in @bm and returns the PFN represented by it. If no more bits are
|
|
|
|
* set, BM_END_OF_MAP is returned.
|
2014-07-21 18:27:01 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* It is required to run memory_bm_position_reset() before the first call to
|
|
|
|
* this function for the given memory bitmap.
|
2014-07-21 18:26:59 +08:00
|
|
|
*/
|
2014-07-21 18:27:01 +08:00
|
|
|
static unsigned long memory_bm_next_pfn(struct memory_bitmap *bm)
|
2014-07-21 18:26:59 +08:00
|
|
|
{
|
|
|
|
unsigned long bits, pfn, pages;
|
|
|
|
int bit;
|
|
|
|
|
|
|
|
do {
|
|
|
|
pages = bm->cur.zone->end_pfn - bm->cur.zone->start_pfn;
|
|
|
|
bits = min(pages - bm->cur.node_pfn, BM_BITS_PER_BLOCK);
|
|
|
|
bit = find_next_bit(bm->cur.node->data, bits,
|
|
|
|
bm->cur.node_bit);
|
|
|
|
if (bit < bits) {
|
|
|
|
pfn = bm->cur.zone->start_pfn + bm->cur.node_pfn + bit;
|
|
|
|
bm->cur.node_bit = bit + 1;
|
2023-07-15 01:55:05 +08:00
|
|
|
bm->cur.cur_pfn = pfn;
|
2014-07-21 18:26:59 +08:00
|
|
|
return pfn;
|
|
|
|
}
|
|
|
|
} while (rtree_next_node(bm));
|
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
bm->cur.cur_pfn = BM_END_OF_MAP;
|
2014-07-21 18:26:59 +08:00
|
|
|
return BM_END_OF_MAP;
|
|
|
|
}
|
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* This structure represents a range of page frames the contents of which
|
|
|
|
* should not be saved during hibernation.
|
2007-05-07 05:50:43 +08:00
|
|
|
*/
|
|
|
|
struct nosave_region {
|
|
|
|
struct list_head list;
|
|
|
|
unsigned long start_pfn;
|
|
|
|
unsigned long end_pfn;
|
|
|
|
};
|
|
|
|
|
|
|
|
static LIST_HEAD(nosave_regions);
|
|
|
|
|
2016-06-29 09:05:10 +08:00
|
|
|
static void recycle_zone_bm_rtree(struct mem_zone_bm_rtree *zone)
|
|
|
|
{
|
|
|
|
struct rtree_node *node;
|
|
|
|
|
|
|
|
list_for_each_entry(node, &zone->nodes, list)
|
|
|
|
recycle_safe_page(node->data);
|
|
|
|
|
|
|
|
list_for_each_entry(node, &zone->leaves, list)
|
|
|
|
recycle_safe_page(node->data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void memory_bm_recycle(struct memory_bitmap *bm)
|
|
|
|
{
|
|
|
|
struct mem_zone_bm_rtree *zone;
|
|
|
|
struct linked_page *p_list;
|
|
|
|
|
|
|
|
list_for_each_entry(zone, &bm->zones, list)
|
|
|
|
recycle_zone_bm_rtree(zone);
|
|
|
|
|
|
|
|
p_list = bm->p_list;
|
|
|
|
while (p_list) {
|
|
|
|
struct linked_page *lp = p_list;
|
|
|
|
|
|
|
|
p_list = lp->next;
|
|
|
|
recycle_safe_page(lp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-07 05:50:43 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* register_nosave_region - Register a region of unsaveable memory.
|
|
|
|
*
|
|
|
|
* Register a range of page frames the contents of which should not be saved
|
|
|
|
* during hibernation (to be used in the early initialization code).
|
2007-05-07 05:50:43 +08:00
|
|
|
*/
|
2022-01-19 18:47:51 +08:00
|
|
|
void __init register_nosave_region(unsigned long start_pfn, unsigned long end_pfn)
|
2007-05-07 05:50:43 +08: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;
|
|
|
|
}
|
|
|
|
}
|
2022-01-19 18:47:51 +08:00
|
|
|
/* This allocation cannot fail */
|
|
|
|
region = memblock_alloc(sizeof(struct nosave_region),
|
|
|
|
SMP_CACHE_BYTES);
|
|
|
|
if (!region)
|
|
|
|
panic("%s: Failed to allocate %zu bytes\n", __func__,
|
|
|
|
sizeof(struct nosave_region));
|
2007-05-07 05:50:43 +08:00
|
|
|
region->start_pfn = start_pfn;
|
|
|
|
region->end_pfn = end_pfn;
|
|
|
|
list_add_tail(®ion->list, &nosave_regions);
|
|
|
|
Report:
|
2017-09-28 13:01:34 +08:00
|
|
|
pr_info("Registered nosave memory: [mem %#010llx-%#010llx]\n",
|
2013-06-04 02:20:29 +08:00
|
|
|
(unsigned long long) start_pfn << PAGE_SHIFT,
|
|
|
|
((unsigned long long) end_pfn << PAGE_SHIFT) - 1);
|
2007-05-07 05:50:43 +08: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));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* mark_nosave_pages - Mark pages that should not be saved.
|
|
|
|
* @bm: Memory bitmap.
|
|
|
|
*
|
|
|
|
* Set the bits in @bm that correspond to the page frames the contents of which
|
|
|
|
* should not be saved.
|
2007-05-07 05:50:43 +08:00
|
|
|
*/
|
|
|
|
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;
|
|
|
|
|
2017-09-28 13:01:34 +08:00
|
|
|
pr_debug("Marking nosave pages: [mem %#010llx-%#010llx]\n",
|
2012-02-15 05:20:52 +08:00
|
|
|
(unsigned long long) region->start_pfn << PAGE_SHIFT,
|
|
|
|
((unsigned long long) region->end_pfn << PAGE_SHIFT)
|
|
|
|
- 1);
|
2007-05-07 05:50:43 +08:00
|
|
|
|
|
|
|
for (pfn = region->start_pfn; pfn < region->end_pfn; pfn++)
|
2008-03-12 07:34:57 +08: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-07 05:50:43 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* create_basic_memory_bitmaps - Create bitmaps to hold basic page information.
|
|
|
|
*
|
|
|
|
* Create bitmaps needed for marking page frames that should not be saved and
|
|
|
|
* free page frames. The forbidden_pages_map and free_pages_map pointers are
|
|
|
|
* only modified if everything goes well, because we don't want the bits to be
|
|
|
|
* touched before both bitmaps are set up.
|
2007-05-07 05:50:43 +08:00
|
|
|
*/
|
|
|
|
int create_basic_memory_bitmaps(void)
|
|
|
|
{
|
|
|
|
struct memory_bitmap *bm1, *bm2;
|
|
|
|
int error = 0;
|
|
|
|
|
2013-10-01 01:40:56 +08:00
|
|
|
if (forbidden_pages_map && free_pages_map)
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
BUG_ON(forbidden_pages_map || free_pages_map);
|
2007-05-07 05:50:43 +08:00
|
|
|
|
2007-05-07 05:50:45 +08:00
|
|
|
bm1 = kzalloc(sizeof(struct memory_bitmap), GFP_KERNEL);
|
2007-05-07 05:50:43 +08:00
|
|
|
if (!bm1)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-05-07 05:50:45 +08:00
|
|
|
error = memory_bm_create(bm1, GFP_KERNEL, PG_ANY);
|
2007-05-07 05:50:43 +08:00
|
|
|
if (error)
|
|
|
|
goto Free_first_object;
|
|
|
|
|
2007-05-07 05:50:45 +08:00
|
|
|
bm2 = kzalloc(sizeof(struct memory_bitmap), GFP_KERNEL);
|
2007-05-07 05:50:43 +08:00
|
|
|
if (!bm2)
|
|
|
|
goto Free_first_bitmap;
|
|
|
|
|
2007-05-07 05:50:45 +08:00
|
|
|
error = memory_bm_create(bm2, GFP_KERNEL, PG_ANY);
|
2007-05-07 05:50:43 +08:00
|
|
|
if (error)
|
|
|
|
goto Free_second_object;
|
|
|
|
|
|
|
|
forbidden_pages_map = bm1;
|
|
|
|
free_pages_map = bm2;
|
|
|
|
mark_nosave_pages(forbidden_pages_map);
|
|
|
|
|
2017-09-28 13:01:34 +08:00
|
|
|
pr_debug("Basic memory bitmaps created\n");
|
2007-05-07 05:50:43 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
Free_second_object:
|
|
|
|
kfree(bm2);
|
|
|
|
Free_first_bitmap:
|
2021-06-08 16:13:14 +08:00
|
|
|
memory_bm_free(bm1, PG_UNSAFE_CLEAR);
|
2007-05-07 05:50:43 +08:00
|
|
|
Free_first_object:
|
|
|
|
kfree(bm1);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* free_basic_memory_bitmaps - Free memory bitmaps holding basic information.
|
|
|
|
*
|
|
|
|
* 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.
|
2007-05-07 05:50:43 +08:00
|
|
|
*/
|
|
|
|
void free_basic_memory_bitmaps(void)
|
|
|
|
{
|
|
|
|
struct memory_bitmap *bm1, *bm2;
|
|
|
|
|
2013-11-15 06:26:58 +08:00
|
|
|
if (WARN_ON(!(forbidden_pages_map && free_pages_map)))
|
|
|
|
return;
|
2007-05-07 05:50:43 +08: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);
|
|
|
|
|
2017-09-28 13:01:34 +08:00
|
|
|
pr_debug("Basic memory bitmaps freed\n");
|
2007-05-07 05:50:43 +08:00
|
|
|
}
|
|
|
|
|
2020-12-15 11:13:38 +08:00
|
|
|
static void clear_or_poison_free_page(struct page *page)
|
|
|
|
{
|
|
|
|
if (page_poisoning_enabled_static())
|
|
|
|
__kernel_poison_pages(page, 1);
|
|
|
|
else if (want_init_on_free())
|
|
|
|
clear_highpage(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
void clear_or_poison_free_pages(void)
|
2016-09-09 16:43:32 +08:00
|
|
|
{
|
|
|
|
struct memory_bitmap *bm = free_pages_map;
|
|
|
|
unsigned long pfn;
|
|
|
|
|
|
|
|
if (WARN_ON(!(free_pages_map)))
|
|
|
|
return;
|
|
|
|
|
2020-12-15 11:13:38 +08:00
|
|
|
if (page_poisoning_enabled() || want_init_on_free()) {
|
2020-01-16 19:09:34 +08:00
|
|
|
memory_bm_position_reset(bm);
|
2016-09-09 16:43:32 +08:00
|
|
|
pfn = memory_bm_next_pfn(bm);
|
2020-01-16 19:09:34 +08:00
|
|
|
while (pfn != BM_END_OF_MAP) {
|
|
|
|
if (pfn_valid(pfn))
|
2020-12-15 11:13:38 +08:00
|
|
|
clear_or_poison_free_page(pfn_to_page(pfn));
|
2020-01-16 19:09:34 +08:00
|
|
|
|
|
|
|
pfn = memory_bm_next_pfn(bm);
|
|
|
|
}
|
|
|
|
memory_bm_position_reset(bm);
|
|
|
|
pr_info("free pages cleared after restore\n");
|
2016-09-09 16:43:32 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-26 14:32:54 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* snapshot_additional_pages - Estimate the number of extra pages needed.
|
|
|
|
* @zone: Memory zone to carry out the computation for.
|
|
|
|
*
|
|
|
|
* Estimate the number of additional pages needed for setting up a hibernation
|
|
|
|
* image data structures for @zone (usually, the returned value is greater than
|
|
|
|
* the exact number).
|
2006-09-26 14:32:54 +08:00
|
|
|
*/
|
|
|
|
unsigned int snapshot_additional_pages(struct zone *zone)
|
|
|
|
{
|
2014-07-21 18:26:57 +08:00
|
|
|
unsigned int rtree, nodes;
|
2006-09-26 14:32:54 +08:00
|
|
|
|
2014-07-21 18:26:57 +08:00
|
|
|
rtree = nodes = DIV_ROUND_UP(zone->spanned_pages, BM_BITS_PER_BLOCK);
|
|
|
|
rtree += DIV_ROUND_UP(rtree * sizeof(struct rtree_node),
|
|
|
|
LINKED_PAGE_DATA_SIZE);
|
|
|
|
while (nodes > 1) {
|
|
|
|
nodes = DIV_ROUND_UP(nodes, BM_ENTRIES_PER_LEVEL);
|
|
|
|
rtree += nodes;
|
|
|
|
}
|
|
|
|
|
2014-07-21 18:27:01 +08:00
|
|
|
return 2 * rtree;
|
2006-09-26 14:32:54 +08:00
|
|
|
}
|
|
|
|
|
2023-05-16 14:38:17 +08:00
|
|
|
/*
|
|
|
|
* Touch the watchdog for every WD_PAGE_COUNT pages.
|
|
|
|
*/
|
|
|
|
#define WD_PAGE_COUNT (128*1024)
|
|
|
|
|
|
|
|
static void mark_free_pages(struct zone *zone)
|
|
|
|
{
|
|
|
|
unsigned long pfn, max_zone_pfn, page_count = WD_PAGE_COUNT;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int order, t;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
if (zone_is_empty(zone))
|
|
|
|
return;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&zone->lock, flags);
|
|
|
|
|
|
|
|
max_zone_pfn = zone_end_pfn(zone);
|
|
|
|
for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
|
|
|
|
if (pfn_valid(pfn)) {
|
|
|
|
page = pfn_to_page(pfn);
|
|
|
|
|
|
|
|
if (!--page_count) {
|
|
|
|
touch_nmi_watchdog();
|
|
|
|
page_count = WD_PAGE_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (page_zone(page) != zone)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!swsusp_page_is_forbidden(page))
|
|
|
|
swsusp_unset_page_free(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
for_each_migratetype_order(order, t) {
|
|
|
|
list_for_each_entry(page,
|
|
|
|
&zone->free_area[order].free_list[t], buddy_list) {
|
|
|
|
unsigned long i;
|
|
|
|
|
|
|
|
pfn = page_to_pfn(page);
|
|
|
|
for (i = 0; i < (1UL << order); i++) {
|
|
|
|
if (!--page_count) {
|
|
|
|
touch_nmi_watchdog();
|
|
|
|
page_count = WD_PAGE_COUNT;
|
|
|
|
}
|
|
|
|
swsusp_set_page_free(pfn_to_page(pfn + i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&zone->lock, flags);
|
|
|
|
}
|
|
|
|
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* count_free_highmem_pages - Compute the total number of free highmem pages.
|
|
|
|
*
|
|
|
|
* The returned number is system-wide.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*/
|
|
|
|
static unsigned int count_free_highmem_pages(void)
|
|
|
|
{
|
|
|
|
struct zone *zone;
|
|
|
|
unsigned int cnt = 0;
|
|
|
|
|
2009-04-01 06:19:31 +08:00
|
|
|
for_each_populated_zone(zone)
|
|
|
|
if (is_highmem(zone))
|
2007-02-10 17:43:02 +08: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-07 12:34:18 +08:00
|
|
|
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* saveable_highmem_page - Check if a highmem page is saveable.
|
|
|
|
*
|
|
|
|
* Determine whether a highmem page should be included in a hibernation image.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* We should save the page if it isn't Nosave or NosaveFree, or Reserved,
|
|
|
|
* and it isn't part of a free chunk of 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-07 12:34:18 +08:00
|
|
|
*/
|
2008-11-27 07:00:24 +08: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-07 12:34:18 +08:00
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
if (!pfn_valid(pfn))
|
|
|
|
return NULL;
|
|
|
|
|
2019-03-06 07:42:45 +08:00
|
|
|
page = pfn_to_online_page(pfn);
|
|
|
|
if (!page || page_zone(page) != zone)
|
2008-11-27 07:00:24 +08: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-07 12:34:18 +08:00
|
|
|
|
|
|
|
BUG_ON(!PageHighMem(page));
|
|
|
|
|
2019-03-06 07:42:50 +08:00
|
|
|
if (swsusp_page_is_forbidden(page) || swsusp_page_is_free(page))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (PageReserved(page) || PageOffline(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-07 12:34:18 +08:00
|
|
|
return NULL;
|
|
|
|
|
2012-01-11 07:07:31 +08: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-07 12:34:18 +08:00
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* count_highmem_pages - Compute the total number of saveable highmem 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-07 12:34:18 +08:00
|
|
|
*/
|
2009-06-12 05:11:17 +08: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-07 12:34:18 +08: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-22 06:36:56 +08: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-07 12:34:18 +08:00
|
|
|
unsigned long pfn, max_zone_pfn;
|
|
|
|
|
|
|
|
if (!is_highmem(zone))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
mark_free_pages(zone);
|
2013-09-12 05:21:44 +08: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-07 12:34:18 +08:00
|
|
|
for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
|
2008-11-27 07:00:24 +08: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-07 12:34:18 +08:00
|
|
|
n++;
|
|
|
|
}
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
#else
|
2008-11-27 07:00:24 +08: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-07 12:34:18 +08:00
|
|
|
#endif /* CONFIG_HIGHMEM */
|
|
|
|
|
2005-10-31 06:59:56 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* saveable_page - Check if the given page is saveable.
|
|
|
|
*
|
|
|
|
* Determine whether a non-highmem page should be included in a hibernation
|
|
|
|
* image.
|
2005-10-31 06:59:56 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08: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 part of
|
|
|
|
* a free chunk of pages.
|
2005-10-31 06:59:56 +08:00
|
|
|
*/
|
2008-11-27 07:00:24 +08:00
|
|
|
static struct page *saveable_page(struct zone *zone, unsigned long pfn)
|
2005-10-31 06:59:56 +08:00
|
|
|
{
|
2005-10-31 06:59:59 +08:00
|
|
|
struct page *page;
|
2005-10-31 06:59:56 +08:00
|
|
|
|
|
|
|
if (!pfn_valid(pfn))
|
2006-09-26 14:32:45 +08:00
|
|
|
return NULL;
|
2005-10-31 06:59:56 +08:00
|
|
|
|
2019-03-06 07:42:45 +08:00
|
|
|
page = pfn_to_online_page(pfn);
|
|
|
|
if (!page || page_zone(page) != zone)
|
2008-11-27 07:00:24 +08:00
|
|
|
return NULL;
|
2006-09-26 14:32:45 +08: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-07 12:34:18 +08:00
|
|
|
BUG_ON(PageHighMem(page));
|
|
|
|
|
2007-05-07 05:50:42 +08:00
|
|
|
if (swsusp_page_is_forbidden(page) || swsusp_page_is_free(page))
|
2006-09-26 14:32:45 +08: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-07 12:34:18 +08:00
|
|
|
|
2019-03-06 07:42:50 +08:00
|
|
|
if (PageOffline(page))
|
|
|
|
return NULL;
|
|
|
|
|
2008-02-20 08:47:44 +08:00
|
|
|
if (PageReserved(page)
|
|
|
|
&& (!kernel_page_present(page) || pfn_is_nosave(pfn)))
|
2006-09-26 14:32:45 +08:00
|
|
|
return NULL;
|
2005-10-31 06:59:56 +08:00
|
|
|
|
2012-01-11 07:07:31 +08:00
|
|
|
if (page_is_guard(page))
|
|
|
|
return NULL;
|
|
|
|
|
2006-09-26 14:32:45 +08:00
|
|
|
return page;
|
2005-10-31 06:59:56 +08: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-07 12:34:18 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* count_data_pages - Compute the total number of saveable non-highmem 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-07 12:34:18 +08:00
|
|
|
*/
|
2009-06-12 05:11:17 +08:00
|
|
|
static unsigned int count_data_pages(void)
|
2005-10-31 06:59:56 +08:00
|
|
|
{
|
|
|
|
struct zone *zone;
|
2006-09-26 14:32:45 +08:00
|
|
|
unsigned long pfn, max_zone_pfn;
|
2005-11-07 16:58:40 +08:00
|
|
|
unsigned int n = 0;
|
2005-10-31 06:59:56 +08: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-22 06:36:56 +08:00
|
|
|
for_each_populated_zone(zone) {
|
2005-10-31 06:59:56 +08: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-07 12:34:18 +08:00
|
|
|
|
2005-10-31 06:59:56 +08:00
|
|
|
mark_free_pages(zone);
|
2013-09-12 05:21:44 +08:00
|
|
|
max_zone_pfn = zone_end_pfn(zone);
|
2006-09-26 14:32:45 +08:00
|
|
|
for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
|
2008-11-27 07:00:24 +08: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-07 12:34:18 +08:00
|
|
|
n++;
|
2005-10-31 06:59:56 +08:00
|
|
|
}
|
2005-10-31 06:59:57 +08:00
|
|
|
return n;
|
2005-10-31 06:59:56 +08:00
|
|
|
}
|
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* This is needed, because copy_page and memcpy are not usable for copying
|
2023-07-15 01:55:05 +08:00
|
|
|
* task structs. Returns true if the page was filled with only zeros,
|
|
|
|
* otherwise false.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*/
|
2023-07-15 01:55:05 +08:00
|
|
|
static inline bool do_copy_page(long *dst, long *src)
|
2006-09-26 14:32:49 +08:00
|
|
|
{
|
2023-07-15 01:55:05 +08:00
|
|
|
long z = 0;
|
2006-09-26 14:32:49 +08:00
|
|
|
int n;
|
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
for (n = PAGE_SIZE / sizeof(long); n; n--) {
|
|
|
|
z |= *src;
|
2006-09-26 14:32:49 +08:00
|
|
|
*dst++ = *src++;
|
2023-07-15 01:55:05 +08:00
|
|
|
}
|
|
|
|
return !z;
|
2006-09-26 14:32:49 +08:00
|
|
|
}
|
|
|
|
|
2008-02-20 08:47:44 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* safe_copy_page - Copy a page in a safe way.
|
|
|
|
*
|
|
|
|
* Check if the page we are going to copy is marked as present in the kernel
|
2019-04-26 08:11:35 +08:00
|
|
|
* page tables. This always is the case if CONFIG_DEBUG_PAGEALLOC or
|
|
|
|
* CONFIG_ARCH_HAS_SET_DIRECT_MAP is not set. In that case kernel_page_present()
|
2023-07-15 01:55:05 +08:00
|
|
|
* always returns 'true'. Returns true if the page was entirely composed of
|
|
|
|
* zeros, otherwise it will return false.
|
2008-02-20 08:47:44 +08:00
|
|
|
*/
|
2023-07-15 01:55:05 +08:00
|
|
|
static bool safe_copy_page(void *dst, struct page *s_page)
|
2008-02-20 08:47:44 +08:00
|
|
|
{
|
2023-07-15 01:55:05 +08:00
|
|
|
bool zeros_only;
|
|
|
|
|
2008-02-20 08:47:44 +08:00
|
|
|
if (kernel_page_present(s_page)) {
|
2023-07-15 01:55:05 +08:00
|
|
|
zeros_only = do_copy_page(dst, page_address(s_page));
|
2008-02-20 08:47:44 +08:00
|
|
|
} else {
|
2020-12-15 11:10:25 +08:00
|
|
|
hibernate_map_page(s_page);
|
2023-07-15 01:55:05 +08:00
|
|
|
zeros_only = do_copy_page(dst, page_address(s_page));
|
2020-12-15 11:10:25 +08:00
|
|
|
hibernate_unmap_page(s_page);
|
2008-02-20 08:47:44 +08:00
|
|
|
}
|
2023-07-15 01:55:05 +08:00
|
|
|
return zeros_only;
|
2008-02-20 08:47:44 +08: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-07 12:34:18 +08:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
2016-07-07 05:42:46 +08:00
|
|
|
static inline struct page *page_is_saveable(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-07 12:34:18 +08:00
|
|
|
{
|
|
|
|
return is_highmem(zone) ?
|
2008-11-27 07:00:24 +08: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-07 12:34:18 +08:00
|
|
|
}
|
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
static bool 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-07 12:34:18 +08:00
|
|
|
{
|
|
|
|
struct page *s_page, *d_page;
|
|
|
|
void *src, *dst;
|
2023-07-15 01:55:05 +08:00
|
|
|
bool zeros_only;
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
|
|
|
|
s_page = pfn_to_page(src_pfn);
|
|
|
|
d_page = pfn_to_page(dst_pfn);
|
|
|
|
if (PageHighMem(s_page)) {
|
2011-11-25 23:14:38 +08:00
|
|
|
src = kmap_atomic(s_page);
|
|
|
|
dst = kmap_atomic(d_page);
|
2023-07-15 01:55:05 +08:00
|
|
|
zeros_only = do_copy_page(dst, src);
|
2011-11-25 23:14:38 +08: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-07 12:34:18 +08:00
|
|
|
} else {
|
|
|
|
if (PageHighMem(d_page)) {
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* The page pointed to by src may contain some kernel
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
* data modified by kmap_atomic()
|
|
|
|
*/
|
2023-07-15 01:55:05 +08:00
|
|
|
zeros_only = safe_copy_page(buffer, s_page);
|
2011-11-25 23:14:38 +08:00
|
|
|
dst = kmap_atomic(d_page);
|
2010-10-27 05:22:27 +08:00
|
|
|
copy_page(dst, buffer);
|
2011-11-25 23:14:38 +08: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-07 12:34:18 +08:00
|
|
|
} else {
|
2023-07-15 01:55:05 +08:00
|
|
|
zeros_only = 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-07 12:34:18 +08:00
|
|
|
}
|
|
|
|
}
|
2023-07-15 01:55:05 +08:00
|
|
|
return zeros_only;
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
}
|
|
|
|
#else
|
2008-11-27 07:00:24 +08: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-07 12:34:18 +08:00
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
static inline int 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-07 12:34:18 +08:00
|
|
|
{
|
2023-07-15 01:55:05 +08:00
|
|
|
return safe_copy_page(page_address(pfn_to_page(dst_pfn)),
|
2008-02-20 08:47:44 +08:00
|
|
|
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-07 12:34:18 +08:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_HIGHMEM */
|
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
/*
|
|
|
|
* Copy data pages will copy all pages into pages pulled from the copy_bm.
|
|
|
|
* If a page was entirely filled with zeros it will be marked in the zero_bm.
|
|
|
|
*
|
|
|
|
* Returns the number of pages copied.
|
|
|
|
*/
|
|
|
|
static unsigned long copy_data_pages(struct memory_bitmap *copy_bm,
|
|
|
|
struct memory_bitmap *orig_bm,
|
|
|
|
struct memory_bitmap *zero_bm)
|
2005-10-31 06:59:56 +08:00
|
|
|
{
|
2023-07-15 01:55:05 +08:00
|
|
|
unsigned long copied_pages = 0;
|
2005-10-31 06:59:56 +08:00
|
|
|
struct zone *zone;
|
2023-07-15 01:55:05 +08:00
|
|
|
unsigned long pfn, copy_pfn;
|
2005-10-31 06:59:56 +08: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-22 06:36:56 +08:00
|
|
|
for_each_populated_zone(zone) {
|
2006-09-26 14:32:54 +08:00
|
|
|
unsigned long max_zone_pfn;
|
|
|
|
|
2005-10-31 06:59:56 +08:00
|
|
|
mark_free_pages(zone);
|
2013-09-12 05:21:44 +08:00
|
|
|
max_zone_pfn = zone_end_pfn(zone);
|
2006-09-26 14:32:54 +08: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-07 12:34:18 +08:00
|
|
|
if (page_is_saveable(zone, pfn))
|
2006-09-26 14:32:54 +08:00
|
|
|
memory_bm_set_bit(orig_bm, pfn);
|
2005-10-31 06:59:56 +08:00
|
|
|
}
|
2006-09-26 14:32:54 +08:00
|
|
|
memory_bm_position_reset(orig_bm);
|
|
|
|
memory_bm_position_reset(copy_bm);
|
2023-07-15 01:55:05 +08:00
|
|
|
copy_pfn = memory_bm_next_pfn(copy_bm);
|
2007-10-20 08:26:04 +08:00
|
|
|
for(;;) {
|
2006-09-26 14:32:54 +08:00
|
|
|
pfn = memory_bm_next_pfn(orig_bm);
|
2007-10-20 08:26:04 +08:00
|
|
|
if (unlikely(pfn == BM_END_OF_MAP))
|
|
|
|
break;
|
2023-07-15 01:55:05 +08:00
|
|
|
if (copy_data_page(copy_pfn, pfn)) {
|
|
|
|
memory_bm_set_bit(zero_bm, pfn);
|
|
|
|
/* Use this copy_pfn for a page that is not full of zeros */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
copied_pages++;
|
|
|
|
copy_pfn = memory_bm_next_pfn(copy_bm);
|
2007-10-20 08:26:04 +08:00
|
|
|
}
|
2023-07-15 01:55:05 +08:00
|
|
|
return copied_pages;
|
2005-10-31 06:59:56 +08: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-07 12:34:18 +08: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;
|
2023-07-15 01:55:05 +08:00
|
|
|
/* Number of zero pages */
|
|
|
|
static unsigned int nr_zero_pages;
|
|
|
|
|
2009-07-08 19:24:05 +08:00
|
|
|
/*
|
|
|
|
* Numbers of normal and highmem page frames allocated for hibernation image
|
|
|
|
* before suspending devices.
|
|
|
|
*/
|
2017-05-11 13:01:24 +08:00
|
|
|
static unsigned int alloc_normal, alloc_highmem;
|
2009-07-08 19:24:05 +08:00
|
|
|
/*
|
|
|
|
* 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-07 12:34:18 +08:00
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
/* Memory bitmap which tracks which saveable pages were zero filled. */
|
|
|
|
static struct memory_bitmap zero_bm;
|
|
|
|
|
2005-10-31 06:59:56 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* swsusp_free - Free pages allocated for hibernation image.
|
2006-09-26 14:32:50 +08:00
|
|
|
*
|
2021-05-24 17:30:10 +08:00
|
|
|
* Image pages are allocated before snapshot creation, so they need to be
|
2016-07-07 05:43:46 +08:00
|
|
|
* released after resume.
|
2005-10-31 06:59:56 +08:00
|
|
|
*/
|
|
|
|
void swsusp_free(void)
|
|
|
|
{
|
2014-09-30 19:31:29 +08:00
|
|
|
unsigned long fb_pfn, fr_pfn;
|
2014-07-21 18:27:00 +08:00
|
|
|
|
2014-09-30 19:31:29 +08:00
|
|
|
if (!forbidden_pages_map || !free_pages_map)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
memory_bm_position_reset(forbidden_pages_map);
|
|
|
|
memory_bm_position_reset(free_pages_map);
|
|
|
|
|
|
|
|
loop:
|
|
|
|
fr_pfn = memory_bm_next_pfn(free_pages_map);
|
|
|
|
fb_pfn = memory_bm_next_pfn(forbidden_pages_map);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the next bit set in both bitmaps. This is guaranteed to
|
|
|
|
* terminate when fb_pfn == fr_pfn == BM_END_OF_MAP.
|
|
|
|
*/
|
|
|
|
do {
|
|
|
|
if (fb_pfn < fr_pfn)
|
|
|
|
fb_pfn = memory_bm_next_pfn(forbidden_pages_map);
|
|
|
|
if (fr_pfn < fb_pfn)
|
|
|
|
fr_pfn = memory_bm_next_pfn(free_pages_map);
|
|
|
|
} while (fb_pfn != fr_pfn);
|
|
|
|
|
|
|
|
if (fr_pfn != BM_END_OF_MAP && pfn_valid(fr_pfn)) {
|
|
|
|
struct page *page = pfn_to_page(fr_pfn);
|
|
|
|
|
|
|
|
memory_bm_clear_current(forbidden_pages_map);
|
|
|
|
memory_bm_clear_current(free_pages_map);
|
2016-07-10 08:12:10 +08:00
|
|
|
hibernate_restore_unprotect_page(page_address(page));
|
2014-09-30 19:31:29 +08:00
|
|
|
__free_page(page);
|
|
|
|
goto loop;
|
2005-10-31 06:59:56 +08:00
|
|
|
}
|
2014-09-30 19:31:29 +08:00
|
|
|
|
|
|
|
out:
|
2006-03-23 18:59:59 +08:00
|
|
|
nr_copy_pages = 0;
|
|
|
|
nr_meta_pages = 0;
|
2023-07-15 01:55:05 +08:00
|
|
|
nr_zero_pages = 0;
|
2006-09-26 14:32:52 +08:00
|
|
|
restore_pblist = NULL;
|
2006-03-23 19:00:03 +08:00
|
|
|
buffer = NULL;
|
2009-07-08 19:24:05 +08:00
|
|
|
alloc_normal = 0;
|
|
|
|
alloc_highmem = 0;
|
2016-07-10 08:12:10 +08:00
|
|
|
hibernate_restore_protection_end();
|
2005-10-31 06:59:56 +08:00
|
|
|
}
|
|
|
|
|
2009-07-08 19:23:51 +08:00
|
|
|
/* Helper functions used for the shrinking of memory. */
|
|
|
|
|
|
|
|
#define GFP_IMAGE (GFP_KERNEL | __GFP_NOWARN)
|
|
|
|
|
2009-06-12 05:11:17 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* preallocate_image_pages - Allocate a number of pages for hibernation image.
|
2009-07-08 19:23:51 +08:00
|
|
|
* @nr_pages: Number of page frames to allocate.
|
|
|
|
* @mask: GFP flags to use for the allocation.
|
2009-06-12 05:11:17 +08:00
|
|
|
*
|
2009-07-08 19:23:51 +08: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 19:24:05 +08:00
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = alloc_image_page(mask);
|
|
|
|
if (!page)
|
2009-07-08 19:23:51 +08:00
|
|
|
break;
|
2009-07-08 19:24:05 +08:00
|
|
|
memory_bm_set_bit(©_bm, page_to_pfn(page));
|
|
|
|
if (PageHighMem(page))
|
|
|
|
alloc_highmem++;
|
|
|
|
else
|
|
|
|
alloc_normal++;
|
2009-07-08 19:23:51 +08:00
|
|
|
nr_pages--;
|
|
|
|
nr_alloc++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return nr_alloc;
|
|
|
|
}
|
|
|
|
|
2010-09-12 02:58:27 +08:00
|
|
|
static unsigned long preallocate_image_memory(unsigned long nr_pages,
|
|
|
|
unsigned long avail_normal)
|
2009-07-08 19:23:51 +08:00
|
|
|
{
|
2010-09-12 02:58:27 +08: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 19:23:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
static unsigned long preallocate_image_highmem(unsigned long nr_pages)
|
|
|
|
{
|
|
|
|
return preallocate_image_pages(nr_pages, GFP_IMAGE | __GFP_HIGHMEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* __fraction - Compute (an approximation of) x * (multiplier / base).
|
2009-06-12 05:11:17 +08:00
|
|
|
*/
|
2009-07-08 19:23:51 +08:00
|
|
|
static unsigned long __fraction(u64 x, u64 multiplier, u64 base)
|
|
|
|
{
|
2020-01-03 23:54:58 +08:00
|
|
|
return div64_u64(x * multiplier, base);
|
2009-07-08 19:23:51 +08:00
|
|
|
}
|
2009-06-12 05:11:17 +08:00
|
|
|
|
2009-07-08 19:23:51 +08:00
|
|
|
static unsigned long preallocate_highmem_fraction(unsigned long nr_pages,
|
2016-07-07 05:42:46 +08:00
|
|
|
unsigned long highmem,
|
|
|
|
unsigned long total)
|
2009-06-12 05:11:17 +08:00
|
|
|
{
|
2009-07-08 19:23:51 +08:00
|
|
|
unsigned long alloc = __fraction(nr_pages, highmem, total);
|
|
|
|
|
|
|
|
return preallocate_image_pages(alloc, GFP_IMAGE | __GFP_HIGHMEM);
|
2009-06-12 05:11:17 +08:00
|
|
|
}
|
2009-07-08 19:23:51 +08: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,
|
2016-07-07 05:42:46 +08:00
|
|
|
unsigned long highmem,
|
|
|
|
unsigned long total)
|
2009-07-08 19:23:51 +08:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_HIGHMEM */
|
2009-06-12 05:11:17 +08:00
|
|
|
|
2009-07-08 19:23:51 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* free_unnecessary_pages - Release preallocated pages not needed for the image.
|
2009-07-08 19:24:05 +08:00
|
|
|
*/
|
2015-02-03 16:22:00 +08:00
|
|
|
static unsigned long free_unnecessary_pages(void)
|
2009-07-08 19:24:05 +08:00
|
|
|
{
|
2015-02-03 16:22:00 +08:00
|
|
|
unsigned long save, to_free_normal, to_free_highmem, free;
|
2009-07-08 19:24:05 +08:00
|
|
|
|
2010-09-12 02:58:27 +08: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 19:24:05 +08:00
|
|
|
} else {
|
|
|
|
to_free_highmem = 0;
|
2011-07-07 02:15:23 +08:00
|
|
|
save -= alloc_highmem;
|
|
|
|
if (to_free_normal > save)
|
|
|
|
to_free_normal -= save;
|
|
|
|
else
|
|
|
|
to_free_normal = 0;
|
2009-07-08 19:24:05 +08:00
|
|
|
}
|
2015-02-03 16:22:00 +08:00
|
|
|
free = to_free_normal + to_free_highmem;
|
2009-07-08 19:24:05 +08:00
|
|
|
|
|
|
|
memory_bm_position_reset(©_bm);
|
|
|
|
|
2010-02-26 05:32:37 +08:00
|
|
|
while (to_free_normal > 0 || to_free_highmem > 0) {
|
2009-07-08 19:24:05 +08: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);
|
|
|
|
}
|
2015-02-03 16:22:00 +08:00
|
|
|
|
|
|
|
return free;
|
2009-07-08 19:24:05 +08:00
|
|
|
}
|
|
|
|
|
2009-07-08 19:24:12 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* minimum_image_size - Estimate the minimum acceptable size of an image.
|
2009-07-08 19:24:12 +08:00
|
|
|
* @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
|
2017-12-22 18:13:59 +08:00
|
|
|
* and (3) inactive anonymous pages, (4) active and (5) inactive file pages.
|
2009-07-08 19:24:12 +08:00
|
|
|
*/
|
|
|
|
static unsigned long minimum_image_size(unsigned long saveable)
|
|
|
|
{
|
|
|
|
unsigned long size;
|
|
|
|
|
2020-08-07 14:20:39 +08:00
|
|
|
size = global_node_page_state_pages(NR_SLAB_RECLAIMABLE_B)
|
2016-07-29 06:45:31 +08:00
|
|
|
+ global_node_page_state(NR_ACTIVE_ANON)
|
|
|
|
+ global_node_page_state(NR_INACTIVE_ANON)
|
|
|
|
+ global_node_page_state(NR_ACTIVE_FILE)
|
2017-12-22 18:13:59 +08:00
|
|
|
+ global_node_page_state(NR_INACTIVE_FILE);
|
2009-07-08 19:24:12 +08:00
|
|
|
|
|
|
|
return saveable <= size ? 0 : saveable - size;
|
|
|
|
}
|
|
|
|
|
2009-07-08 19:24:05 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* hibernate_preallocate_memory - Preallocate memory for hibernation image.
|
2009-07-08 19:23:51 +08: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 17:38:48 +08:00
|
|
|
* callbacks (these two numbers are given by PAGES_FOR_IO (which is a rough
|
2020-02-14 22:06:21 +08:00
|
|
|
* estimate) and reserved_size divided by PAGE_SIZE (which is tunable through
|
2011-05-15 17:38:48 +08:00
|
|
|
* /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 19:23:51 +08:00
|
|
|
*
|
2022-11-01 10:28:39 +08:00
|
|
|
* ([page frames total] - PAGES_FOR_IO - [metadata pages]) / 2
|
|
|
|
* - 2 * DIV_ROUND_UP(reserved_size, PAGE_SIZE)
|
2009-07-08 19:23:51 +08: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 19:24:12 +08: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 19:23:51 +08:00
|
|
|
*/
|
2009-07-08 19:24:05 +08:00
|
|
|
int hibernate_preallocate_memory(void)
|
2009-06-12 05:11:17 +08:00
|
|
|
{
|
|
|
|
struct zone *zone;
|
2009-07-08 19:23:51 +08:00
|
|
|
unsigned long saveable, size, max_size, count, highmem, pages = 0;
|
2010-09-12 02:58:27 +08:00
|
|
|
unsigned long alloc, save_highmem, pages_highmem, avail_normal;
|
2014-10-31 02:04:53 +08:00
|
|
|
ktime_t start, stop;
|
2009-07-08 19:24:05 +08:00
|
|
|
int error;
|
2009-06-12 05:11:17 +08:00
|
|
|
|
2020-01-03 07:19:40 +08:00
|
|
|
pr_info("Preallocating image memory\n");
|
2014-10-31 02:04:53 +08:00
|
|
|
start = ktime_get();
|
2009-06-12 05:11:17 +08:00
|
|
|
|
2009-07-08 19:24:05 +08:00
|
|
|
error = memory_bm_create(&orig_bm, GFP_IMAGE, PG_ANY);
|
2020-01-03 07:19:40 +08:00
|
|
|
if (error) {
|
|
|
|
pr_err("Cannot allocate original bitmap\n");
|
2009-07-08 19:24:05 +08:00
|
|
|
goto err_out;
|
2020-01-03 07:19:40 +08:00
|
|
|
}
|
2009-07-08 19:24:05 +08:00
|
|
|
|
|
|
|
error = memory_bm_create(©_bm, GFP_IMAGE, PG_ANY);
|
2020-01-03 07:19:40 +08:00
|
|
|
if (error) {
|
|
|
|
pr_err("Cannot allocate copy bitmap\n");
|
2009-07-08 19:24:05 +08:00
|
|
|
goto err_out;
|
2020-01-03 07:19:40 +08:00
|
|
|
}
|
2009-07-08 19:24:05 +08:00
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
error = memory_bm_create(&zero_bm, GFP_IMAGE, PG_ANY);
|
|
|
|
if (error) {
|
|
|
|
pr_err("Cannot allocate zero bitmap\n");
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
2009-07-08 19:24:05 +08:00
|
|
|
alloc_normal = 0;
|
|
|
|
alloc_highmem = 0;
|
2023-07-15 01:55:05 +08:00
|
|
|
nr_zero_pages = 0;
|
2009-07-08 19:24:05 +08:00
|
|
|
|
2009-07-08 19:23:51 +08:00
|
|
|
/* Count the number of saveable data pages. */
|
2009-07-08 19:24:05 +08:00
|
|
|
save_highmem = count_highmem_pages();
|
2009-07-08 19:23:51 +08:00
|
|
|
saveable = count_data_pages();
|
2009-06-12 05:11:17 +08:00
|
|
|
|
2009-07-08 19:23:51 +08: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 19:24:05 +08:00
|
|
|
saveable += save_highmem;
|
|
|
|
highmem = save_highmem;
|
2009-07-08 19:23:51 +08: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-12 02:58:27 +08:00
|
|
|
avail_normal = count;
|
2009-07-08 19:23:51 +08:00
|
|
|
count += highmem;
|
|
|
|
count -= totalreserve_pages;
|
|
|
|
|
|
|
|
/* Compute the maximum number of saveable pages to leave in memory. */
|
2011-05-15 17:38:48 +08:00
|
|
|
max_size = (count - (size + PAGES_FOR_IO)) / 2
|
|
|
|
- 2 * DIV_ROUND_UP(reserved_size, PAGE_SIZE);
|
2010-09-21 01:44:38 +08:00
|
|
|
/* Compute the desired number of image pages specified by image_size. */
|
2009-07-08 19:23:51 +08:00
|
|
|
size = DIV_ROUND_UP(image_size, PAGE_SIZE);
|
|
|
|
if (size > max_size)
|
|
|
|
size = max_size;
|
|
|
|
/*
|
2010-09-21 01:44:38 +08: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 19:23:51 +08:00
|
|
|
*/
|
2009-07-08 19:24:05 +08:00
|
|
|
if (size >= saveable) {
|
|
|
|
pages = preallocate_image_highmem(save_highmem);
|
2010-09-12 02:58:27 +08:00
|
|
|
pages += preallocate_image_memory(saveable - pages, avail_normal);
|
2009-07-08 19:23:51 +08:00
|
|
|
goto out;
|
2009-07-08 19:24:05 +08:00
|
|
|
}
|
2009-07-08 19:23:51 +08:00
|
|
|
|
2009-07-08 19:24:12 +08:00
|
|
|
/* Estimate the minimum size of the image. */
|
|
|
|
pages = minimum_image_size(saveable);
|
2010-09-12 02:58:27 +08: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 19:24:12 +08:00
|
|
|
if (size < pages)
|
|
|
|
size = min_t(unsigned long, pages, max_size);
|
|
|
|
|
2009-07-08 19:23:51 +08: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 19:24:12 +08:00
|
|
|
* of the image as much as indicated by 'size' using allocations from
|
|
|
|
* highmem and non-highmem zones separately.
|
2009-07-08 19:23:51 +08:00
|
|
|
*/
|
|
|
|
pages_highmem = preallocate_image_highmem(highmem / 2);
|
2013-11-06 08:41:31 +08:00
|
|
|
alloc = count - max_size;
|
|
|
|
if (alloc > pages_highmem)
|
|
|
|
alloc -= pages_highmem;
|
|
|
|
else
|
|
|
|
alloc = 0;
|
2010-09-12 02:58:27 +08: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);
|
2020-01-03 07:19:40 +08:00
|
|
|
if (pages_highmem < alloc) {
|
|
|
|
pr_err("Image allocation is %lu pages short\n",
|
|
|
|
alloc - pages_highmem);
|
2010-09-12 02:58:27 +08:00
|
|
|
goto err_out;
|
2020-01-03 07:19:40 +08:00
|
|
|
}
|
2010-09-12 02:58:27 +08:00
|
|
|
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 19:23:51 +08:00
|
|
|
|
2009-07-08 19:24:05 +08: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.
|
|
|
|
*/
|
2015-02-03 16:22:00 +08:00
|
|
|
pages -= free_unnecessary_pages();
|
2009-07-08 19:23:51 +08:00
|
|
|
|
|
|
|
out:
|
2014-10-31 02:04:53 +08:00
|
|
|
stop = ktime_get();
|
2020-01-10 18:08:12 +08:00
|
|
|
pr_info("Allocated %lu pages for snapshot\n", pages);
|
2014-10-31 02:04:53 +08:00
|
|
|
swsusp_show_speed(start, stop, pages, "Allocated");
|
2009-06-12 05:11:17 +08:00
|
|
|
|
|
|
|
return 0;
|
2009-07-08 19:24:05 +08:00
|
|
|
|
|
|
|
err_out:
|
|
|
|
swsusp_free();
|
|
|
|
return -ENOMEM;
|
2009-06-12 05:11:17 +08: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-07 12:34:18 +08:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* count_pages_for_highmem - Count non-highmem pages needed for copying highmem.
|
|
|
|
*
|
|
|
|
* Compute the number of non-highmem pages that will be necessary for creating
|
|
|
|
* copies of highmem 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-07 12:34:18 +08:00
|
|
|
static unsigned int count_pages_for_highmem(unsigned int nr_highmem)
|
|
|
|
{
|
2009-07-08 19:24:05 +08: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-07 12:34:18 +08:00
|
|
|
|
|
|
|
if (free_highmem >= nr_highmem)
|
|
|
|
nr_highmem = 0;
|
|
|
|
else
|
|
|
|
nr_highmem -= free_highmem;
|
|
|
|
|
|
|
|
return nr_highmem;
|
|
|
|
}
|
|
|
|
#else
|
2016-07-07 05:42:46 +08:00
|
|
|
static unsigned int count_pages_for_highmem(unsigned int nr_highmem) { 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-07 12:34:18 +08:00
|
|
|
#endif /* CONFIG_HIGHMEM */
|
2005-10-31 06:59:56 +08:00
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* enough_free_mem - Check if there is enough free memory for the image.
|
2005-10-31 06:59:56 +08: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-07 12:34:18 +08:00
|
|
|
static int enough_free_mem(unsigned int nr_pages, unsigned int nr_highmem)
|
2005-10-31 06:59:56 +08:00
|
|
|
{
|
2006-01-06 16:14:20 +08:00
|
|
|
struct zone *zone;
|
2009-07-08 19:24:05 +08:00
|
|
|
unsigned int free = alloc_normal;
|
2006-01-06 16:14:20 +08: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-22 06:36:56 +08: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-07 12:34:18 +08:00
|
|
|
if (!is_highmem(zone))
|
2007-02-10 17:43:02 +08: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 14:32:55 +08: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-07 12:34:18 +08:00
|
|
|
nr_pages += count_pages_for_highmem(nr_highmem);
|
2017-09-28 13:01:34 +08:00
|
|
|
pr_debug("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 14:32:55 +08:00
|
|
|
|
2009-07-08 19:24:05 +08:00
|
|
|
return free > nr_pages + PAGES_FOR_IO;
|
2005-10-31 06:59:56 +08: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-07 12:34:18 +08:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* get_highmem_buffer - Allocate a buffer for highmem pages.
|
|
|
|
*
|
|
|
|
* If there are some highmem pages in the hibernation image, we may need a
|
|
|
|
* buffer to copy them and/or load their data.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*/
|
|
|
|
static inline int get_highmem_buffer(int safe_needed)
|
|
|
|
{
|
2017-11-16 09:38:03 +08:00
|
|
|
buffer = get_image_page(GFP_ATOMIC, safe_needed);
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
return buffer ? 0 : -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2022-03-25 09:44:15 +08:00
|
|
|
* alloc_highmem_pages - Allocate some highmem pages for the image.
|
2016-07-07 05:43:46 +08:00
|
|
|
*
|
|
|
|
* Try to allocate as many pages as needed, but if the number of free highmem
|
|
|
|
* pages is less than that, allocate them all.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*/
|
2016-07-07 05:42:46 +08:00
|
|
|
static inline unsigned int 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-07 12:34:18 +08: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;
|
|
|
|
|
2015-11-07 08:28:21 +08:00
|
|
|
page = alloc_image_page(__GFP_HIGHMEM|__GFP_KSWAPD_RECLAIM);
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
memory_bm_set_bit(bm, page_to_pfn(page));
|
|
|
|
}
|
|
|
|
return nr_highmem;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline int get_highmem_buffer(int safe_needed) { return 0; }
|
|
|
|
|
2016-07-07 05:42:46 +08:00
|
|
|
static inline unsigned int 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-07 12:34:18 +08:00
|
|
|
#endif /* CONFIG_HIGHMEM */
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* swsusp_alloc - Allocate memory for hibernation image.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* 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.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* 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.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*/
|
2017-06-27 08:10:44 +08:00
|
|
|
static int swsusp_alloc(struct memory_bitmap *copy_bm,
|
2016-07-07 05:42:46 +08:00
|
|
|
unsigned int nr_pages, unsigned int nr_highmem)
|
2005-11-09 13:34:39 +08: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-07 12:34:18 +08:00
|
|
|
if (nr_highmem > 0) {
|
2011-02-13 04:06:51 +08:00
|
|
|
if (get_highmem_buffer(PG_ANY))
|
2009-07-08 19:24:05 +08: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-07 12:34:18 +08:00
|
|
|
}
|
2009-07-08 19:24:05 +08:00
|
|
|
if (nr_pages > alloc_normal) {
|
|
|
|
nr_pages -= alloc_normal;
|
|
|
|
while (nr_pages-- > 0) {
|
|
|
|
struct page *page;
|
|
|
|
|
2017-11-16 09:38:03 +08:00
|
|
|
page = alloc_image_page(GFP_ATOMIC);
|
2009-07-08 19:24:05 +08:00
|
|
|
if (!page)
|
|
|
|
goto err_out;
|
|
|
|
memory_bm_set_bit(copy_bm, page_to_pfn(page));
|
|
|
|
}
|
2005-10-31 06:59:56 +08:00
|
|
|
}
|
2009-07-08 19:24:05 +08:00
|
|
|
|
2006-09-26 14:32:54 +08:00
|
|
|
return 0;
|
2005-10-31 06:59:56 +08:00
|
|
|
|
2009-07-08 19:24:05 +08:00
|
|
|
err_out:
|
2006-09-26 14:32:54 +08:00
|
|
|
swsusp_free();
|
2011-02-13 04:06:51 +08:00
|
|
|
return -ENOMEM;
|
2005-10-31 06:59:56 +08:00
|
|
|
}
|
|
|
|
|
2014-05-02 06:44:38 +08:00
|
|
|
asmlinkage __visible int swsusp_save(void)
|
2005-10-31 06:59:56 +08: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-07 12:34:18 +08:00
|
|
|
unsigned int nr_pages, nr_highmem;
|
2005-10-31 06:59:56 +08:00
|
|
|
|
2020-01-03 07:19:40 +08:00
|
|
|
pr_info("Creating image:\n");
|
2005-10-31 06:59:56 +08:00
|
|
|
|
2008-02-05 14:29:11 +08:00
|
|
|
drain_local_pages(NULL);
|
2005-10-31 06:59:57 +08: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-07 12:34:18 +08:00
|
|
|
nr_highmem = count_highmem_pages();
|
2017-09-28 13:01:34 +08:00
|
|
|
pr_info("Need to copy %u pages\n", nr_pages + nr_highmem);
|
2005-10-31 06:59:56 +08: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-07 12:34:18 +08:00
|
|
|
if (!enough_free_mem(nr_pages, nr_highmem)) {
|
2017-09-28 13:01:34 +08:00
|
|
|
pr_err("Not enough free memory\n");
|
2005-10-31 06:59:56 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2017-06-27 08:10:44 +08:00
|
|
|
if (swsusp_alloc(©_bm, nr_pages, nr_highmem)) {
|
2017-09-28 13:01:34 +08:00
|
|
|
pr_err("Memory allocation failed\n");
|
2005-10-31 06:59:57 +08: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-07 12:34:18 +08:00
|
|
|
}
|
2005-10-31 06:59:56 +08:00
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* During allocating of suspend pagedir, new cold pages may appear.
|
2005-10-31 06:59:56 +08:00
|
|
|
* Kill them.
|
|
|
|
*/
|
2008-02-05 14:29:11 +08:00
|
|
|
drain_local_pages(NULL);
|
2023-07-15 01:55:05 +08:00
|
|
|
nr_copy_pages = copy_data_pages(©_bm, &orig_bm, &zero_bm);
|
2005-10-31 06:59:56 +08: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-07 12:34:18 +08:00
|
|
|
nr_pages += nr_highmem;
|
2023-07-15 01:55:05 +08:00
|
|
|
/* We don't actually copy the zero pages */
|
|
|
|
nr_zero_pages = nr_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-07 12:34:18 +08:00
|
|
|
nr_meta_pages = DIV_ROUND_UP(nr_pages * sizeof(long), PAGE_SIZE);
|
2005-10-31 06:59:57 +08:00
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
pr_info("Image created (%d pages copied, %d zero pages)\n", nr_copy_pages, nr_zero_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-07 12:34:18 +08:00
|
|
|
|
2005-10-31 06:59:56 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2006-03-23 18:59:59 +08:00
|
|
|
|
2007-10-18 18:04:52 +08:00
|
|
|
#ifndef CONFIG_ARCH_HIBERNATION_HEADER
|
|
|
|
static int init_header_complete(struct swsusp_info *info)
|
2006-03-23 18:59:59 +08:00
|
|
|
{
|
2007-10-18 18:04:52 +08:00
|
|
|
memcpy(&info->uts, init_utsname(), sizeof(struct new_utsname));
|
2006-03-23 18:59:59 +08:00
|
|
|
info->version_code = LINUX_VERSION_CODE;
|
2007-10-18 18:04:52 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-07-11 03:12:10 +08:00
|
|
|
static const char *check_image_kernel(struct swsusp_info *info)
|
2007-10-18 18:04:52 +08:00
|
|
|
{
|
|
|
|
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-26 06:59:31 +08:00
|
|
|
unsigned long snapshot_get_image_size(void)
|
|
|
|
{
|
|
|
|
return nr_copy_pages + nr_meta_pages + 1;
|
|
|
|
}
|
|
|
|
|
2007-10-18 18:04:52 +08:00
|
|
|
static int init_header(struct swsusp_info *info)
|
|
|
|
{
|
|
|
|
memset(info, 0, sizeof(struct swsusp_info));
|
2013-07-04 06:03:43 +08:00
|
|
|
info->num_physpages = get_num_physpages();
|
2006-03-23 18:59:59 +08:00
|
|
|
info->image_pages = nr_copy_pages;
|
2007-10-26 06:59:31 +08:00
|
|
|
info->pages = snapshot_get_image_size();
|
2006-03-23 19:00:03 +08:00
|
|
|
info->size = info->pages;
|
|
|
|
info->size <<= PAGE_SHIFT;
|
2007-10-18 18:04:52 +08:00
|
|
|
return init_header_complete(info);
|
2006-03-23 18:59:59 +08:00
|
|
|
}
|
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
#define ENCODED_PFN_ZERO_FLAG ((unsigned long)1 << (BITS_PER_LONG - 1))
|
|
|
|
#define ENCODED_PFN_MASK (~ENCODED_PFN_ZERO_FLAG)
|
|
|
|
|
2006-03-23 18:59:59 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* pack_pfns - Prepare PFNs for saving.
|
|
|
|
* @bm: Memory bitmap.
|
|
|
|
* @buf: Memory buffer to store the PFNs in.
|
2023-07-15 01:55:05 +08:00
|
|
|
* @zero_bm: Memory bitmap containing PFNs of zero pages.
|
2016-07-07 05:43:46 +08:00
|
|
|
*
|
|
|
|
* PFNs corresponding to set bits in @bm are stored in the area of memory
|
2023-07-15 01:55:05 +08:00
|
|
|
* pointed to by @buf (1 page at a time). Pages which were filled with only
|
|
|
|
* zeros will have the highest bit set in the packed format to distinguish
|
|
|
|
* them from PFNs which will be contained in the image file.
|
2006-03-23 18:59:59 +08:00
|
|
|
*/
|
2023-07-15 01:55:05 +08:00
|
|
|
static inline void pack_pfns(unsigned long *buf, struct memory_bitmap *bm,
|
|
|
|
struct memory_bitmap *zero_bm)
|
2006-03-23 18:59:59 +08:00
|
|
|
{
|
|
|
|
int j;
|
|
|
|
|
2006-09-26 14:32:54 +08: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 14:32:55 +08:00
|
|
|
buf[j] = memory_bm_next_pfn(bm);
|
|
|
|
if (unlikely(buf[j] == BM_END_OF_MAP))
|
2006-09-26 14:32:54 +08:00
|
|
|
break;
|
2023-07-15 01:55:05 +08:00
|
|
|
if (memory_bm_test_bit(zero_bm, buf[j]))
|
|
|
|
buf[j] |= ENCODED_PFN_ZERO_FLAG;
|
2006-03-23 18:59:59 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* snapshot_read_next - Get the address to read the next image page from.
|
|
|
|
* @handle: Snapshot handle to be used for the reading.
|
2006-03-23 18:59:59 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* On the first call, @handle should point to a zeroed snapshot_handle
|
|
|
|
* structure. The structure gets populated then and a pointer to it should be
|
|
|
|
* passed to this function every next time.
|
2006-03-23 18:59:59 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* 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
|
|
|
|
* location computed by the data_of() macro.
|
2006-03-23 18:59:59 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* The function returns 0 to indicate the end of the data stream condition,
|
|
|
|
* and negative numbers are returned on errors. If that happens, the structure
|
|
|
|
* pointed to by @handle is not updated and should not be used any more.
|
2006-03-23 18:59:59 +08:00
|
|
|
*/
|
2010-05-02 05:52:02 +08:00
|
|
|
int snapshot_read_next(struct snapshot_handle *handle)
|
2006-03-23 18:59:59 +08:00
|
|
|
{
|
2006-09-26 14:32:46 +08:00
|
|
|
if (handle->cur > nr_meta_pages + nr_copy_pages)
|
2006-03-23 18:59:59 +08:00
|
|
|
return 0;
|
2006-09-26 14:32:54 +08:00
|
|
|
|
2006-03-23 18:59:59 +08: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-07 12:34:18 +08:00
|
|
|
buffer = get_image_page(GFP_ATOMIC, PG_ANY);
|
2006-03-23 18:59:59 +08:00
|
|
|
if (!buffer)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2010-05-02 05:52:02 +08:00
|
|
|
if (!handle->cur) {
|
2007-10-18 18:04:52 +08:00
|
|
|
int error;
|
|
|
|
|
|
|
|
error = init_header((struct swsusp_info *)buffer);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2006-03-23 18:59:59 +08:00
|
|
|
handle->buffer = buffer;
|
2006-09-26 14:32:54 +08:00
|
|
|
memory_bm_position_reset(&orig_bm);
|
|
|
|
memory_bm_position_reset(©_bm);
|
2010-05-02 05:52:02 +08:00
|
|
|
} else if (handle->cur <= nr_meta_pages) {
|
2010-10-27 05:22:27 +08:00
|
|
|
clear_page(buffer);
|
2023-07-15 01:55:05 +08:00
|
|
|
pack_pfns(buffer, &orig_bm, &zero_bm);
|
2010-05-02 05:52:02 +08:00
|
|
|
} else {
|
|
|
|
struct page *page;
|
2006-09-26 14:32:54 +08:00
|
|
|
|
2010-05-02 05:52:02 +08:00
|
|
|
page = pfn_to_page(memory_bm_next_pfn(©_bm));
|
|
|
|
if (PageHighMem(page)) {
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* Highmem pages are copied to the buffer,
|
2010-05-02 05:52:02 +08:00
|
|
|
* 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-07 12:34:18 +08:00
|
|
|
|
2011-11-25 23:14:38 +08:00
|
|
|
kaddr = kmap_atomic(page);
|
2010-10-27 05:22:27 +08:00
|
|
|
copy_page(buffer, kaddr);
|
2011-11-25 23:14:38 +08:00
|
|
|
kunmap_atomic(kaddr);
|
2010-05-02 05:52:02 +08:00
|
|
|
handle->buffer = buffer;
|
|
|
|
} else {
|
|
|
|
handle->buffer = page_address(page);
|
2006-03-23 18:59:59 +08:00
|
|
|
}
|
|
|
|
}
|
2010-05-02 05:52:02 +08:00
|
|
|
handle->cur++;
|
|
|
|
return PAGE_SIZE;
|
2006-03-23 18:59:59 +08:00
|
|
|
}
|
|
|
|
|
2016-06-29 09:02:16 +08:00
|
|
|
static void duplicate_memory_bitmap(struct memory_bitmap *dst,
|
|
|
|
struct memory_bitmap *src)
|
|
|
|
{
|
|
|
|
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 18:59:59 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* mark_unsafe_pages - Mark pages that were used before hibernation.
|
|
|
|
*
|
|
|
|
* Mark the pages that cannot be used for storing the image during restoration,
|
|
|
|
* because they conflict with the pages that had been used before hibernation.
|
2006-03-23 18:59:59 +08:00
|
|
|
*/
|
2016-06-29 09:02:16 +08:00
|
|
|
static void mark_unsafe_pages(struct memory_bitmap *bm)
|
2006-03-23 18:59:59 +08:00
|
|
|
{
|
2016-06-29 09:02:16 +08:00
|
|
|
unsigned long pfn;
|
2006-03-23 18:59:59 +08:00
|
|
|
|
2016-06-29 09:02:16 +08:00
|
|
|
/* Clear the "free"/"unsafe" bit for all PFNs */
|
|
|
|
memory_bm_position_reset(free_pages_map);
|
|
|
|
pfn = memory_bm_next_pfn(free_pages_map);
|
|
|
|
while (pfn != BM_END_OF_MAP) {
|
|
|
|
memory_bm_clear_current(free_pages_map);
|
|
|
|
pfn = memory_bm_next_pfn(free_pages_map);
|
2006-03-23 18:59:59 +08:00
|
|
|
}
|
|
|
|
|
2016-06-29 09:02:16 +08:00
|
|
|
/* Mark pages that correspond to the "original" PFNs as "unsafe" */
|
|
|
|
duplicate_memory_bitmap(free_pages_map, bm);
|
2006-03-23 18:59:59 +08: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 14:32:55 +08:00
|
|
|
allocated_unsafe_pages = 0;
|
2006-03-23 18:59:59 +08:00
|
|
|
}
|
|
|
|
|
2007-10-18 18:04:52 +08:00
|
|
|
static int check_header(struct swsusp_info *info)
|
2006-03-23 18:59:59 +08:00
|
|
|
{
|
2020-07-11 03:12:10 +08:00
|
|
|
const char *reason;
|
2006-03-23 18:59:59 +08:00
|
|
|
|
2007-10-18 18:04:52 +08:00
|
|
|
reason = check_image_kernel(info);
|
2013-07-04 06:03:43 +08:00
|
|
|
if (!reason && info->num_physpages != get_num_physpages())
|
2006-03-23 18:59:59 +08:00
|
|
|
reason = "memory size";
|
|
|
|
if (reason) {
|
2017-09-28 13:01:34 +08:00
|
|
|
pr_err("Image mismatch: %s\n", reason);
|
2006-03-23 18:59:59 +08:00
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2022-03-25 09:44:15 +08:00
|
|
|
* load_header - Check the image header and copy the data from it.
|
2006-03-23 18:59:59 +08:00
|
|
|
*/
|
2016-07-07 05:42:46 +08:00
|
|
|
static int load_header(struct swsusp_info *info)
|
2006-03-23 18:59:59 +08: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 14:32:55 +08:00
|
|
|
restore_pblist = NULL;
|
2006-03-23 18:59:59 +08:00
|
|
|
error = check_header(info);
|
|
|
|
if (!error) {
|
|
|
|
nr_copy_pages = info->image_pages;
|
|
|
|
nr_meta_pages = info->pages - info->image_pages - 1;
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* unpack_orig_pfns - Set bits corresponding to given PFNs in a memory bitmap.
|
|
|
|
* @bm: Memory bitmap.
|
|
|
|
* @buf: Area of memory containing the PFNs.
|
2023-07-15 01:55:05 +08:00
|
|
|
* @zero_bm: Memory bitmap with the zero PFNs marked.
|
2016-07-07 05:43:46 +08:00
|
|
|
*
|
|
|
|
* For each element of the array pointed to by @buf (1 page at a time), set the
|
2023-07-15 01:55:05 +08:00
|
|
|
* corresponding bit in @bm. If the page was originally populated with only
|
|
|
|
* zeros then a corresponding bit will also be set in @zero_bm.
|
2006-03-23 18:59:59 +08:00
|
|
|
*/
|
2023-07-15 01:55:05 +08:00
|
|
|
static int unpack_orig_pfns(unsigned long *buf, struct memory_bitmap *bm,
|
|
|
|
struct memory_bitmap *zero_bm)
|
2006-03-23 18:59:59 +08:00
|
|
|
{
|
2023-07-15 01:55:05 +08:00
|
|
|
unsigned long decoded_pfn;
|
|
|
|
bool zero;
|
2006-03-23 18:59:59 +08: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 14:32:55 +08:00
|
|
|
for (j = 0; j < PAGE_SIZE / sizeof(long); j++) {
|
|
|
|
if (unlikely(buf[j] == BM_END_OF_MAP))
|
|
|
|
break;
|
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
zero = !!(buf[j] & ENCODED_PFN_ZERO_FLAG);
|
|
|
|
decoded_pfn = buf[j] & ENCODED_PFN_MASK;
|
|
|
|
if (pfn_valid(decoded_pfn) && memory_bm_pfn_present(bm, decoded_pfn)) {
|
|
|
|
memory_bm_set_bit(bm, decoded_pfn);
|
|
|
|
if (zero) {
|
|
|
|
memory_bm_set_bit(zero_bm, decoded_pfn);
|
|
|
|
nr_zero_pages++;
|
|
|
|
}
|
2022-11-11 13:19:49 +08:00
|
|
|
} else {
|
2023-07-15 01:55:05 +08:00
|
|
|
if (!pfn_valid(decoded_pfn))
|
2022-11-11 13:19:49 +08:00
|
|
|
pr_err(FW_BUG "Memory map mismatch at 0x%llx after hibernation\n",
|
2023-07-15 01:55:05 +08:00
|
|
|
(unsigned long long)PFN_PHYS(decoded_pfn));
|
2008-11-12 04:32:44 +08:00
|
|
|
return -EFAULT;
|
2022-11-11 13:19:49 +08:00
|
|
|
}
|
2006-03-23 18:59:59 +08:00
|
|
|
}
|
2008-11-12 04:32:44 +08:00
|
|
|
|
|
|
|
return 0;
|
2006-03-23 18:59:59 +08: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-07 12:34:18 +08:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* struct highmem_pbe is used for creating the list of highmem pages that
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
* 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;
|
|
|
|
};
|
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* List of highmem PBEs needed for restoring the highmem pages that were
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
* 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;
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* count_highmem_image_pages - Compute the number of highmem pages in the image.
|
|
|
|
* @bm: Memory bitmap.
|
|
|
|
*
|
|
|
|
* The bits in @bm that correspond to image pages are assumed to be set.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*/
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int safe_highmem_pages;
|
|
|
|
|
|
|
|
static struct memory_bitmap *safe_highmem_bm;
|
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/**
|
|
|
|
* prepare_highmem_image - Allocate memory for loading highmem data from image.
|
|
|
|
* @bm: Pointer to an uninitialized memory bitmap structure.
|
|
|
|
* @nr_highmem_p: Pointer to the number of highmem image pages.
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
* hibernation image is restored entirely) have the corresponding bits set in
|
2021-05-24 17:30:10 +08:00
|
|
|
* @bm (it must be uninitialized).
|
2016-07-07 05:43:46 +08:00
|
|
|
*
|
|
|
|
* NOTE: This function should not be called if there are no highmem image pages.
|
|
|
|
*/
|
2016-07-07 05:42:46 +08:00
|
|
|
static int prepare_highmem_image(struct memory_bitmap *bm,
|
|
|
|
unsigned int *nr_highmem_p)
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
{
|
|
|
|
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-07 05:50:42 +08: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-07 12:34:18 +08: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-07 05:50:42 +08: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-07 12:34:18 +08:00
|
|
|
}
|
|
|
|
memory_bm_position_reset(bm);
|
|
|
|
safe_highmem_bm = bm;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
static struct page *last_highmem_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-07 12:34:18 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* get_highmem_page_buffer - Prepare a buffer to store a highmem image page.
|
|
|
|
*
|
|
|
|
* For a given highmem image page get a buffer that suspend_write_next() should
|
|
|
|
* return to its caller to write to.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* 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.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* 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.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*/
|
2016-07-07 05:42:46 +08:00
|
|
|
static void *get_highmem_page_buffer(struct page *page,
|
|
|
|
struct chain_allocator *ca)
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
{
|
|
|
|
struct highmem_pbe *pbe;
|
|
|
|
void *kaddr;
|
|
|
|
|
2007-05-07 05:50:42 +08:00
|
|
|
if (swsusp_page_is_forbidden(page) && swsusp_page_is_free(page)) {
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* We have allocated the "original" page frame and we can
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
* use it directly to store the loaded page.
|
|
|
|
*/
|
|
|
|
last_highmem_page = page;
|
|
|
|
return buffer;
|
|
|
|
}
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* The "original" page frame has not been allocated and we have to
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
* use a "safe" page frame to store the loaded page.
|
|
|
|
*/
|
|
|
|
pbe = chain_alloc(ca, sizeof(struct highmem_pbe));
|
|
|
|
if (!pbe) {
|
|
|
|
swsusp_free();
|
2008-11-12 04:32:44 +08: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-07 12:34:18 +08: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 */
|
2023-09-22 01:00:45 +08:00
|
|
|
kaddr = __get_safe_page(ca->gfp_mask);
|
|
|
|
if (!kaddr)
|
|
|
|
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-07 12:34:18 +08:00
|
|
|
pbe->copy_page = virt_to_page(kaddr);
|
|
|
|
}
|
|
|
|
pbe->next = highmem_pblist;
|
|
|
|
highmem_pblist = pbe;
|
|
|
|
return kaddr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* copy_last_highmem_page - Copy most the most recent highmem image page.
|
|
|
|
*
|
|
|
|
* Copy the contents of a highmem image from @buffer, where the caller of
|
|
|
|
* snapshot_write_next() has stored them, to the right location represented by
|
|
|
|
* @last_highmem_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-07 12:34:18 +08:00
|
|
|
*/
|
|
|
|
static void copy_last_highmem_page(void)
|
|
|
|
{
|
|
|
|
if (last_highmem_page) {
|
|
|
|
void *dst;
|
|
|
|
|
2011-11-25 23:14:38 +08:00
|
|
|
dst = kmap_atomic(last_highmem_page);
|
2010-10-27 05:22:27 +08:00
|
|
|
copy_page(dst, buffer);
|
2011-11-25 23:14:38 +08: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-07 12:34:18 +08: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
|
2016-07-07 05:42:46 +08:00
|
|
|
static unsigned int count_highmem_image_pages(struct memory_bitmap *bm) { 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-07 12:34:18 +08:00
|
|
|
|
2016-07-07 05:42:46 +08:00
|
|
|
static inline int prepare_highmem_image(struct memory_bitmap *bm,
|
|
|
|
unsigned int *nr_highmem_p) { 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-07 12:34:18 +08:00
|
|
|
|
2016-07-07 05:42:46 +08:00
|
|
|
static inline void *get_highmem_page_buffer(struct page *page,
|
|
|
|
struct chain_allocator *ca)
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
{
|
2008-11-12 04:32:44 +08: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-07 12:34:18 +08: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 */
|
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
#define PBES_PER_LINKED_PAGE (LINKED_PAGE_DATA_SIZE / sizeof(struct pbe))
|
|
|
|
|
2006-03-23 18:59:59 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* prepare_image - Make room for loading hibernation image.
|
2021-05-24 17:30:10 +08:00
|
|
|
* @new_bm: Uninitialized memory bitmap structure.
|
2016-07-07 05:43:46 +08:00
|
|
|
* @bm: Memory bitmap with unsafe pages marked.
|
2023-07-15 01:55:05 +08:00
|
|
|
* @zero_bm: Memory bitmap containing the zero pages.
|
2016-07-07 05:43:46 +08:00
|
|
|
*
|
|
|
|
* Use @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 17:04:48 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* The idea is to allocate a new memory bitmap first and then allocate
|
|
|
|
* as many pages as needed for image data, but without specifying what those
|
|
|
|
* pages will be used for just yet. Instead, we mark them all as allocated and
|
|
|
|
* create a lists of "safe" pages to be used later. On systems with high
|
|
|
|
* memory a list of "safe" highmem pages is created too.
|
2023-07-15 01:55:05 +08:00
|
|
|
*
|
|
|
|
* Because it was not known which pages were unsafe when @zero_bm was created,
|
|
|
|
* make a copy of it and recreate it within safe pages.
|
2006-03-23 18:59:59 +08:00
|
|
|
*/
|
2023-07-15 01:55:05 +08:00
|
|
|
static int prepare_image(struct memory_bitmap *new_bm, struct memory_bitmap *bm,
|
|
|
|
struct memory_bitmap *zero_bm)
|
2006-03-23 18:59:59 +08: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-07 12:34:18 +08:00
|
|
|
unsigned int nr_pages, nr_highmem;
|
2023-07-15 01:55:05 +08:00
|
|
|
struct memory_bitmap tmp;
|
2016-06-29 09:00:51 +08:00
|
|
|
struct linked_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 14:32:55 +08:00
|
|
|
int error;
|
2006-03-23 18:59:59 +08: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-07 12:34:18 +08: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);
|
2016-06-29 09:02:16 +08:00
|
|
|
mark_unsafe_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 14:32:55 +08:00
|
|
|
|
|
|
|
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);
|
2023-07-15 01:55:05 +08:00
|
|
|
|
|
|
|
/* Make a copy of zero_bm so it can be created in safe pages */
|
2023-10-04 13:01:15 +08:00
|
|
|
error = memory_bm_create(&tmp, GFP_ATOMIC, PG_SAFE);
|
2023-07-15 01:55:05 +08:00
|
|
|
if (error)
|
|
|
|
goto Free;
|
|
|
|
|
|
|
|
duplicate_memory_bitmap(&tmp, zero_bm);
|
|
|
|
memory_bm_free(zero_bm, PG_UNSAFE_KEEP);
|
|
|
|
|
|
|
|
/* Recreate zero_bm in safe pages */
|
|
|
|
error = memory_bm_create(zero_bm, GFP_ATOMIC, PG_SAFE);
|
|
|
|
if (error)
|
|
|
|
goto Free;
|
|
|
|
|
|
|
|
duplicate_memory_bitmap(zero_bm, &tmp);
|
2023-10-04 13:01:15 +08:00
|
|
|
memory_bm_free(&tmp, PG_UNSAFE_CLEAR);
|
2023-07-15 01:55:05 +08:00
|
|
|
/* At this point zero_bm is in safe pages and it can be used for restoring. */
|
|
|
|
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
if (nr_highmem > 0) {
|
|
|
|
error = prepare_highmem_image(bm, &nr_highmem);
|
|
|
|
if (error)
|
|
|
|
goto Free;
|
|
|
|
}
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* Reserve some safe pages for potential later use.
|
[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 14:32:55 +08:00
|
|
|
*
|
|
|
|
* 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.
|
2016-06-29 09:00:51 +08:00
|
|
|
*
|
|
|
|
* nr_copy_pages cannot be less than allocated_unsafe_pages too.
|
[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 14:32:55 +08:00
|
|
|
*/
|
2023-07-15 01:55:05 +08:00
|
|
|
nr_pages = (nr_zero_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 14:32:55 +08: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-07 12:34:18 +08: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 14:32:55 +08:00
|
|
|
if (!lp) {
|
2006-03-23 18:59:59 +08: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 14:32:55 +08:00
|
|
|
goto Free;
|
|
|
|
}
|
2016-06-29 09:00:51 +08:00
|
|
|
lp->next = safe_pages_list;
|
|
|
|
safe_pages_list = 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 14:32:55 +08:00
|
|
|
nr_pages--;
|
2006-03-23 18:59:59 +08: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 14:32:55 +08:00
|
|
|
/* Preallocate memory for the image */
|
2023-07-15 01:55:05 +08:00
|
|
|
nr_pages = (nr_zero_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 14:32:55 +08:00
|
|
|
while (nr_pages > 0) {
|
|
|
|
lp = (struct linked_page *)get_zeroed_page(GFP_ATOMIC);
|
|
|
|
if (!lp) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto Free;
|
|
|
|
}
|
2007-05-07 05:50:42 +08: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 14:32:55 +08:00
|
|
|
/* The page is "safe", add it to the list */
|
|
|
|
lp->next = safe_pages_list;
|
|
|
|
safe_pages_list = lp;
|
2006-06-23 17:04:48 +08: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 14:32:55 +08:00
|
|
|
/* Mark the page as allocated */
|
2007-05-07 05:50:42 +08: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 14:32:55 +08:00
|
|
|
nr_pages--;
|
2006-06-23 17:04:48 +08: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 14:32:55 +08:00
|
|
|
return 0;
|
|
|
|
|
2006-12-07 12:34:44 +08: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 14:32:55 +08:00
|
|
|
swsusp_free();
|
2006-03-23 18:59:59 +08: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 14:32:55 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* get_buffer - Get the address to store the next image data page.
|
|
|
|
*
|
|
|
|
* Get the address that snapshot_write_next() should return to its caller to
|
|
|
|
* write to.
|
[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 14:32:55 +08:00
|
|
|
*/
|
|
|
|
static void *get_buffer(struct memory_bitmap *bm, struct chain_allocator *ca)
|
2006-06-23 17:04:48 +08: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 14:32:55 +08:00
|
|
|
struct pbe *pbe;
|
2008-11-12 04:32:44 +08:00
|
|
|
struct page *page;
|
|
|
|
unsigned long pfn = memory_bm_next_pfn(bm);
|
2006-06-23 17:04:48 +08:00
|
|
|
|
2008-11-12 04:32:44 +08: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-07 12:34:18 +08:00
|
|
|
if (PageHighMem(page))
|
|
|
|
return get_highmem_page_buffer(page, ca);
|
|
|
|
|
2007-05-07 05:50:42 +08:00
|
|
|
if (swsusp_page_is_forbidden(page) && swsusp_page_is_free(page))
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* We have allocated the "original" page frame and we can
|
[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 14:32:55 +08:00
|
|
|
* use it directly to store the loaded page.
|
2006-06-23 17:04:48 +08: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 14:32:55 +08:00
|
|
|
return page_address(page);
|
|
|
|
|
2016-07-07 05:43:46 +08:00
|
|
|
/*
|
|
|
|
* The "original" page frame has not been allocated and we have to
|
[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 14:32:55 +08:00
|
|
|
* use a "safe" page frame to store the loaded page.
|
2006-06-23 17:04:48 +08: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 14:32:55 +08:00
|
|
|
pbe = chain_alloc(ca, sizeof(struct pbe));
|
|
|
|
if (!pbe) {
|
|
|
|
swsusp_free();
|
2008-11-12 04:32:44 +08: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 14:32:55 +08: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-07 12:34:18 +08:00
|
|
|
pbe->orig_address = page_address(page);
|
2023-09-22 01:00:45 +08:00
|
|
|
pbe->address = __get_safe_page(ca->gfp_mask);
|
|
|
|
if (!pbe->address)
|
|
|
|
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 14:32:55 +08:00
|
|
|
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-07 12:34:18 +08:00
|
|
|
return pbe->address;
|
2006-06-23 17:04:48 +08:00
|
|
|
}
|
|
|
|
|
2006-03-23 18:59:59 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* snapshot_write_next - Get the address to store the next image page.
|
|
|
|
* @handle: Snapshot handle structure to guide the writing.
|
2006-03-23 18:59:59 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* On the first call, @handle should point to a zeroed snapshot_handle
|
|
|
|
* structure. The structure gets populated then and a pointer to it should be
|
|
|
|
* passed to this function every next time.
|
2006-03-23 18:59:59 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* 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
|
|
|
|
* location computed by the data_of() macro.
|
2006-03-23 18:59:59 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* The function returns 0 to indicate the "end of file" condition. Negative
|
|
|
|
* numbers are returned on errors, in which cases the structure pointed to by
|
|
|
|
* @handle is not updated and should not be used any more.
|
2006-03-23 18:59:59 +08:00
|
|
|
*/
|
2010-05-02 05:52:02 +08:00
|
|
|
int snapshot_write_next(struct snapshot_handle *handle)
|
2006-03-23 18:59:59 +08: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 14:32:55 +08:00
|
|
|
static struct chain_allocator ca;
|
2006-03-23 18:59:59 +08:00
|
|
|
int error = 0;
|
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
next:
|
[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 14:32:55 +08:00
|
|
|
/* Check if we have already loaded the entire image */
|
2023-07-15 01:55:05 +08:00
|
|
|
if (handle->cur > 1 && handle->cur > nr_meta_pages + nr_copy_pages + nr_zero_pages)
|
2006-03-23 18:59:59 +08: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 14:32:55 +08:00
|
|
|
|
2010-05-02 05:52:02 +08:00
|
|
|
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-07 12:34:18 +08:00
|
|
|
if (!buffer)
|
|
|
|
/* This makes the buffer be freed by swsusp_free() */
|
|
|
|
buffer = get_image_page(GFP_ATOMIC, PG_ANY);
|
|
|
|
|
2006-03-23 18:59:59 +08: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-07 12:34:18 +08:00
|
|
|
|
2006-03-23 18:59:59 +08:00
|
|
|
handle->buffer = buffer;
|
2010-05-02 05:52:02 +08: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 14:32:55 +08:00
|
|
|
|
2016-06-29 09:00:51 +08:00
|
|
|
safe_pages_list = NULL;
|
|
|
|
|
2010-05-02 05:52:02 +08:00
|
|
|
error = memory_bm_create(©_bm, GFP_ATOMIC, PG_ANY);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2023-07-15 01:55:05 +08:00
|
|
|
error = memory_bm_create(&zero_bm, GFP_ATOMIC, PG_ANY);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
nr_zero_pages = 0;
|
|
|
|
|
2016-07-10 08:12:10 +08:00
|
|
|
hibernate_restore_protection_begin();
|
2010-05-02 05:52:02 +08:00
|
|
|
} else if (handle->cur <= nr_meta_pages + 1) {
|
2023-07-15 01:55:05 +08:00
|
|
|
error = unpack_orig_pfns(buffer, ©_bm, &zero_bm);
|
2010-05-02 05:52:02 +08:00
|
|
|
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 14:32:55 +08:00
|
|
|
|
2010-05-02 05:52:02 +08:00
|
|
|
if (handle->cur == nr_meta_pages + 1) {
|
2023-07-15 01:55:05 +08:00
|
|
|
error = prepare_image(&orig_bm, ©_bm, &zero_bm);
|
2008-11-12 04:32:44 +08:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2010-05-02 05:52:02 +08:00
|
|
|
chain_init(&ca, GFP_ATOMIC, PG_SAFE);
|
|
|
|
memory_bm_position_reset(&orig_bm);
|
2023-07-15 01:55:05 +08:00
|
|
|
memory_bm_position_reset(&zero_bm);
|
2010-05-02 05:52:02 +08:00
|
|
|
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 14:32:55 +08:00
|
|
|
handle->buffer = get_buffer(&orig_bm, &ca);
|
2008-11-12 04:32:44 +08:00
|
|
|
if (IS_ERR(handle->buffer))
|
|
|
|
return PTR_ERR(handle->buffer);
|
2006-03-23 18:59:59 +08:00
|
|
|
}
|
|
|
|
} else {
|
2010-05-02 05:52:02 +08:00
|
|
|
copy_last_highmem_page();
|
2016-07-10 08:12:10 +08:00
|
|
|
hibernate_restore_protect_page(handle->buffer);
|
2010-05-02 05:52:02 +08:00
|
|
|
handle->buffer = get_buffer(&orig_bm, &ca);
|
|
|
|
if (IS_ERR(handle->buffer))
|
|
|
|
return PTR_ERR(handle->buffer);
|
2006-03-23 18:59:59 +08:00
|
|
|
}
|
2023-09-23 00:07:04 +08:00
|
|
|
handle->sync_read = (handle->buffer == buffer);
|
2010-05-02 05:52:02 +08:00
|
|
|
handle->cur++;
|
2023-07-15 01:55:05 +08:00
|
|
|
|
|
|
|
/* Zero pages were not included in the image, memset it and move on. */
|
|
|
|
if (handle->cur > nr_meta_pages + 1 &&
|
|
|
|
memory_bm_test_bit(&zero_bm, memory_bm_get_current(&orig_bm))) {
|
|
|
|
memset(handle->buffer, 0, PAGE_SIZE);
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
|
2010-05-02 05:52:02 +08:00
|
|
|
return PAGE_SIZE;
|
2006-03-23 18:59:59 +08: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-07 12:34:18 +08:00
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* snapshot_write_finalize - Complete the loading of a hibernation image.
|
|
|
|
*
|
|
|
|
* 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 highmem. Additionally, it recycles bitmap memory that's not
|
|
|
|
* necessary any more.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*/
|
|
|
|
void snapshot_write_finalize(struct snapshot_handle *handle)
|
|
|
|
{
|
|
|
|
copy_last_highmem_page();
|
2016-07-10 08:12:10 +08:00
|
|
|
hibernate_restore_protect_page(handle->buffer);
|
2016-06-29 09:05:10 +08:00
|
|
|
/* Do that only if we have loaded the image entirely */
|
2023-07-15 01:55:05 +08:00
|
|
|
if (handle->cur > 1 && handle->cur > nr_meta_pages + nr_copy_pages + nr_zero_pages) {
|
2016-06-29 09:05:10 +08:00
|
|
|
memory_bm_recycle(&orig_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-07 12:34:18 +08:00
|
|
|
free_highmem_data();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-03-23 18:59:59 +08: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-07 12:34:18 +08:00
|
|
|
return !(!nr_copy_pages || !last_highmem_page_copied() ||
|
2023-07-15 01:55:05 +08:00
|
|
|
handle->cur <= nr_meta_pages + nr_copy_pages + nr_zero_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 14:32:55 +08: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-07 12:34:18 +08:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
/* Assumes that @buf is ready and points to a "safe" page */
|
2016-07-07 05:42:46 +08:00
|
|
|
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 14:32:55 +08: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-07 12:34:18 +08:00
|
|
|
void *kaddr1, *kaddr2;
|
|
|
|
|
2011-11-25 23:14:38 +08:00
|
|
|
kaddr1 = kmap_atomic(p1);
|
|
|
|
kaddr2 = kmap_atomic(p2);
|
2010-10-27 05:22:27 +08:00
|
|
|
copy_page(buf, kaddr1);
|
|
|
|
copy_page(kaddr1, kaddr2);
|
|
|
|
copy_page(kaddr2, buf);
|
2011-11-25 23:14:38 +08: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-07 12:34:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-07 05:43:46 +08:00
|
|
|
* restore_highmem - Put highmem image pages into their original locations.
|
|
|
|
*
|
|
|
|
* For each highmem page that was in use before hibernation and is included in
|
|
|
|
* the image, and also has been allocated by the "restore" kernel, swap its
|
|
|
|
* current contents with the previous (ie. "before hibernation") ones.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*
|
2016-07-07 05:43:46 +08:00
|
|
|
* If the restore eventually fails, we can call this function once again and
|
|
|
|
* restore the highmem state as seen by the restore kernel.
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
*/
|
|
|
|
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 18:59:59 +08: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-07 12:34:18 +08:00
|
|
|
#endif /* CONFIG_HIGHMEM */
|