2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/suspend.h>
|
|
|
|
#include <linux/utsname.h>
|
|
|
|
|
|
|
|
struct swsusp_info {
|
|
|
|
struct new_utsname uts;
|
|
|
|
u32 version_code;
|
|
|
|
unsigned long num_physpages;
|
|
|
|
int cpus;
|
|
|
|
unsigned long image_pages;
|
2006-01-06 09:13:05 +01:00
|
|
|
unsigned long pages;
|
2006-03-23 12:00:03 +01:00
|
|
|
unsigned long size;
|
2005-04-17 00:20:36 +02:00
|
|
|
} __attribute__((aligned(PAGE_SIZE)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SOFTWARE_SUSPEND
|
|
|
|
extern int pm_suspend_disk(void);
|
|
|
|
|
|
|
|
#else
|
|
|
|
static inline int pm_suspend_disk(void)
|
|
|
|
{
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
#endif
|
2006-12-07 05:34:35 +01:00
|
|
|
|
2007-05-02 19:27:07 +02:00
|
|
|
extern int pfn_is_nosave(unsigned long);
|
|
|
|
|
2006-12-07 05:34:35 +01:00
|
|
|
extern struct mutex pm_mutex;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#define power_attr(_name) \
|
|
|
|
static struct subsys_attribute _name##_attr = { \
|
|
|
|
.attr = { \
|
|
|
|
.name = __stringify(_name), \
|
|
|
|
.mode = 0644, \
|
|
|
|
}, \
|
|
|
|
.show = _name##_show, \
|
|
|
|
.store = _name##_store, \
|
|
|
|
}
|
|
|
|
|
2007-04-13 22:15:19 +02:00
|
|
|
extern struct kset power_subsys;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-02-01 12:05:07 +01:00
|
|
|
/* Preferred image size in bytes (default 500 MB) */
|
|
|
|
extern unsigned long image_size;
|
2006-03-23 11:59:59 +01:00
|
|
|
extern int in_suspend;
|
2006-03-23 12:00:00 +01:00
|
|
|
extern dev_t swsusp_resume_device;
|
2006-12-07 05:34:12 +01:00
|
|
|
extern sector_t swsusp_resume_block;
|
2006-03-23 11:59:59 +01:00
|
|
|
|
2005-10-30 23:59:56 +01:00
|
|
|
extern asmlinkage int swsusp_arch_suspend(void);
|
|
|
|
extern asmlinkage int swsusp_arch_resume(void);
|
|
|
|
|
2007-05-06 23:50:43 +02:00
|
|
|
extern int create_basic_memory_bitmaps(void);
|
|
|
|
extern void free_basic_memory_bitmaps(void);
|
2006-01-06 09:13:46 +01:00
|
|
|
extern unsigned int count_data_pages(void);
|
2006-03-23 11:59:59 +01:00
|
|
|
|
2006-09-26 08:32:46 +02:00
|
|
|
/**
|
|
|
|
* Auxiliary structure used for reading the snapshot image data and
|
|
|
|
* metadata from and writing them to the list of page backup entries
|
|
|
|
* (PBEs) which is the main data structure of swsusp.
|
|
|
|
*
|
|
|
|
* Using struct snapshot_handle we can transfer the image, including its
|
|
|
|
* metadata, as a continuous sequence of bytes with the help of
|
|
|
|
* snapshot_read_next() and snapshot_write_next().
|
|
|
|
*
|
|
|
|
* The code that writes the image to a storage or transfers it to
|
|
|
|
* the user land is required to use snapshot_read_next() for this
|
|
|
|
* purpose and it should not make any assumptions regarding the internal
|
|
|
|
* structure of the image. Similarly, the code that reads the image from
|
|
|
|
* a storage or transfers it from the user land is required to use
|
|
|
|
* snapshot_write_next().
|
|
|
|
*
|
|
|
|
* This may allow us to change the internal structure of the image
|
|
|
|
* in the future with considerably less effort.
|
|
|
|
*/
|
|
|
|
|
2006-03-23 11:59:59 +01:00
|
|
|
struct snapshot_handle {
|
2006-09-26 08:32:46 +02:00
|
|
|
loff_t offset; /* number of the last byte ready for reading
|
|
|
|
* or writing in the sequence
|
|
|
|
*/
|
|
|
|
unsigned int cur; /* number of the block of PAGE_SIZE bytes the
|
|
|
|
* next operation will refer to (ie. current)
|
|
|
|
*/
|
|
|
|
unsigned int cur_offset; /* offset with respect to the current
|
|
|
|
* block (for the next operation)
|
|
|
|
*/
|
|
|
|
unsigned int prev; /* number of the block of PAGE_SIZE bytes that
|
|
|
|
* was the current one previously
|
|
|
|
*/
|
|
|
|
void *buffer; /* address of the block to read from
|
|
|
|
* or write to
|
|
|
|
*/
|
|
|
|
unsigned int buf_offset; /* location to read from or write to,
|
|
|
|
* given as a displacement from 'buffer'
|
|
|
|
*/
|
|
|
|
int sync_read; /* Set to one to notify the caller of
|
|
|
|
* snapshot_write_next() that it may
|
|
|
|
* need to call wait_on_bio_chain()
|
|
|
|
*/
|
2006-03-23 11:59:59 +01:00
|
|
|
};
|
|
|
|
|
2006-09-26 08:32:46 +02:00
|
|
|
/* This macro returns the address from/to which the caller of
|
|
|
|
* snapshot_read_next()/snapshot_write_next() is allowed to
|
|
|
|
* read/write data after the function returns
|
|
|
|
*/
|
2006-03-23 11:59:59 +01:00
|
|
|
#define data_of(handle) ((handle).buffer + (handle).buf_offset)
|
|
|
|
|
2006-09-26 08:32:54 +02:00
|
|
|
extern unsigned int snapshot_additional_pages(struct zone *zone);
|
2006-03-23 11:59:59 +01:00
|
|
|
extern int snapshot_read_next(struct snapshot_handle *handle, size_t count);
|
|
|
|
extern int snapshot_write_next(struct snapshot_handle *handle, size_t count);
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 05:34:18 +01:00
|
|
|
extern void snapshot_write_finalize(struct snapshot_handle *handle);
|
2006-09-26 08:32:54 +02:00
|
|
|
extern int snapshot_image_loaded(struct snapshot_handle *handle);
|
2006-03-23 12:00:00 +01:00
|
|
|
|
2006-12-07 05:34:15 +01:00
|
|
|
/*
|
|
|
|
* This structure is used to pass the values needed for the identification
|
|
|
|
* of the resume swap area from a user space to the kernel via the
|
|
|
|
* SNAPSHOT_SET_SWAP_AREA ioctl
|
|
|
|
*/
|
|
|
|
struct resume_swap_area {
|
|
|
|
loff_t offset;
|
|
|
|
u_int32_t dev;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
2006-03-23 12:00:03 +01:00
|
|
|
#define SNAPSHOT_IOC_MAGIC '3'
|
|
|
|
#define SNAPSHOT_FREEZE _IO(SNAPSHOT_IOC_MAGIC, 1)
|
|
|
|
#define SNAPSHOT_UNFREEZE _IO(SNAPSHOT_IOC_MAGIC, 2)
|
|
|
|
#define SNAPSHOT_ATOMIC_SNAPSHOT _IOW(SNAPSHOT_IOC_MAGIC, 3, void *)
|
|
|
|
#define SNAPSHOT_ATOMIC_RESTORE _IO(SNAPSHOT_IOC_MAGIC, 4)
|
|
|
|
#define SNAPSHOT_FREE _IO(SNAPSHOT_IOC_MAGIC, 5)
|
|
|
|
#define SNAPSHOT_SET_IMAGE_SIZE _IOW(SNAPSHOT_IOC_MAGIC, 6, unsigned long)
|
|
|
|
#define SNAPSHOT_AVAIL_SWAP _IOR(SNAPSHOT_IOC_MAGIC, 7, void *)
|
|
|
|
#define SNAPSHOT_GET_SWAP_PAGE _IOR(SNAPSHOT_IOC_MAGIC, 8, void *)
|
|
|
|
#define SNAPSHOT_FREE_SWAP_PAGES _IO(SNAPSHOT_IOC_MAGIC, 9)
|
|
|
|
#define SNAPSHOT_SET_SWAP_FILE _IOW(SNAPSHOT_IOC_MAGIC, 10, unsigned int)
|
2006-03-23 12:00:09 +01:00
|
|
|
#define SNAPSHOT_S2RAM _IO(SNAPSHOT_IOC_MAGIC, 11)
|
2006-12-07 05:34:06 +01:00
|
|
|
#define SNAPSHOT_PMOPS _IOW(SNAPSHOT_IOC_MAGIC, 12, unsigned int)
|
2006-12-07 05:34:15 +01:00
|
|
|
#define SNAPSHOT_SET_SWAP_AREA _IOW(SNAPSHOT_IOC_MAGIC, 13, \
|
|
|
|
struct resume_swap_area)
|
|
|
|
#define SNAPSHOT_IOC_MAXNR 13
|
2006-12-07 05:34:06 +01:00
|
|
|
|
|
|
|
#define PMOPS_PREPARE 1
|
|
|
|
#define PMOPS_ENTER 2
|
|
|
|
#define PMOPS_FINISH 3
|
2006-03-23 12:00:03 +01:00
|
|
|
|
2006-03-23 12:00:00 +01:00
|
|
|
/**
|
|
|
|
* The bitmap is used for tracing allocated swap pages
|
|
|
|
*
|
|
|
|
* The entire bitmap consists of a number of bitmap_page
|
|
|
|
* structures linked with the help of the .next member.
|
|
|
|
* Thus each page can be allocated individually, so we only
|
|
|
|
* need to make 0-order memory allocations to create
|
|
|
|
* the bitmap.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define BITMAP_PAGE_SIZE (PAGE_SIZE - sizeof(void *))
|
|
|
|
#define BITMAP_PAGE_CHUNKS (BITMAP_PAGE_SIZE / sizeof(long))
|
|
|
|
#define BITS_PER_CHUNK (sizeof(long) * 8)
|
|
|
|
#define BITMAP_PAGE_BITS (BITMAP_PAGE_CHUNKS * BITS_PER_CHUNK)
|
|
|
|
|
|
|
|
struct bitmap_page {
|
|
|
|
unsigned long chunks[BITMAP_PAGE_CHUNKS];
|
|
|
|
struct bitmap_page *next;
|
|
|
|
};
|
|
|
|
|
|
|
|
extern void free_bitmap(struct bitmap_page *bitmap);
|
|
|
|
extern struct bitmap_page *alloc_bitmap(unsigned int nr_bits);
|
2006-12-07 05:34:10 +01:00
|
|
|
extern sector_t alloc_swapdev_block(int swap, struct bitmap_page *bitmap);
|
2006-03-23 12:00:00 +01:00
|
|
|
extern void free_all_swap_pages(int swap, struct bitmap_page *bitmap);
|
|
|
|
|
2006-03-23 12:00:01 +01:00
|
|
|
extern int swsusp_check(void);
|
2006-03-23 12:00:00 +01:00
|
|
|
extern int swsusp_shrink_memory(void);
|
2006-03-23 12:00:01 +01:00
|
|
|
extern void swsusp_free(void);
|
2006-03-23 12:00:00 +01:00
|
|
|
extern int swsusp_suspend(void);
|
|
|
|
extern int swsusp_resume(void);
|
2006-03-23 12:00:01 +01:00
|
|
|
extern int swsusp_read(void);
|
|
|
|
extern int swsusp_write(void);
|
|
|
|
extern void swsusp_close(void);
|
2006-03-23 12:00:09 +01:00
|
|
|
extern int suspend_enter(suspend_state_t state);
|
2006-12-07 05:34:32 +01:00
|
|
|
|
|
|
|
struct timeval;
|
|
|
|
extern void swsusp_show_speed(struct timeval *, struct timeval *,
|
|
|
|
unsigned int, char *);
|