2 * linux/kernel/power/swap.c
4 * This file provides functions for reading the suspend image from
5 * and writing it to a swap partition.
7 * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@suse.cz>
8 * Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
10 * This file is released under the GPLv2.
14 #include <linux/module.h>
15 #include <linux/file.h>
16 #include <linux/delay.h>
17 #include <linux/bitops.h>
18 #include <linux/genhd.h>
19 #include <linux/device.h>
20 #include <linux/buffer_head.h>
21 #include <linux/bio.h>
22 #include <linux/blkdev.h>
23 #include <linux/swap.h>
24 #include <linux/swapops.h>
26 #include <linux/slab.h>
30 #define SWSUSP_SIG "S1SUSPEND"
33 * The swap map is a data structure used for keeping track of each page
34 * written to a swap partition. It consists of many swap_map_page
35 * structures that contain each an array of MAP_PAGE_SIZE swap entries.
36 * These structures are stored on the swap and linked together with the
37 * help of the .next_swap member.
39 * The swap map is created during suspend. The swap map pages are
40 * allocated and populated one at a time, so we only need one memory
41 * page to set up the entire structure.
43 * During resume we also only need to use one swap_map_page structure
47 #define MAP_PAGE_ENTRIES (PAGE_SIZE / sizeof(sector_t) - 1)
49 struct swap_map_page {
50 sector_t entries[MAP_PAGE_ENTRIES];
55 * The swap_map_handle structure is used for handling swap in
59 struct swap_map_handle {
60 struct swap_map_page *cur;
62 sector_t first_sector;
66 struct swsusp_header {
67 char reserved[PAGE_SIZE - 20 - sizeof(sector_t) - sizeof(int)];
69 unsigned int flags; /* Flags to pass to the "boot" kernel */
72 } __attribute__((packed));
74 static struct swsusp_header *swsusp_header;
77 * The following functions are used for tracing the allocated
78 * swap pages, so that they can be freed in case of an error.
81 struct swsusp_extent {
87 static struct rb_root swsusp_extents = RB_ROOT;
89 static int swsusp_extents_insert(unsigned long swap_offset)
91 struct rb_node **new = &(swsusp_extents.rb_node);
92 struct rb_node *parent = NULL;
93 struct swsusp_extent *ext;
95 /* Figure out where to put the new node */
97 ext = container_of(*new, struct swsusp_extent, node);
99 if (swap_offset < ext->start) {
101 if (swap_offset == ext->start - 1) {
105 new = &((*new)->rb_left);
106 } else if (swap_offset > ext->end) {
108 if (swap_offset == ext->end + 1) {
112 new = &((*new)->rb_right);
114 /* It already is in the tree */
118 /* Add the new node and rebalance the tree. */
119 ext = kzalloc(sizeof(struct swsusp_extent), GFP_KERNEL);
123 ext->start = swap_offset;
124 ext->end = swap_offset;
125 rb_link_node(&ext->node, parent, new);
126 rb_insert_color(&ext->node, &swsusp_extents);
131 * alloc_swapdev_block - allocate a swap page and register that it has
132 * been allocated, so that it can be freed in case of an error.
135 sector_t alloc_swapdev_block(int swap)
137 unsigned long offset;
139 offset = swp_offset(get_swap_page_of_type(swap));
141 if (swsusp_extents_insert(offset))
142 swap_free(swp_entry(swap, offset));
144 return swapdev_block(swap, offset);
150 * free_all_swap_pages - free swap pages allocated for saving image data.
151 * It also frees the extents used to register which swap entres had been
155 void free_all_swap_pages(int swap)
157 struct rb_node *node;
159 while ((node = swsusp_extents.rb_node)) {
160 struct swsusp_extent *ext;
161 unsigned long offset;
163 ext = container_of(node, struct swsusp_extent, node);
164 rb_erase(node, &swsusp_extents);
165 for (offset = ext->start; offset <= ext->end; offset++)
166 swap_free(swp_entry(swap, offset));
172 int swsusp_swap_in_use(void)
174 return (swsusp_extents.rb_node != NULL);
181 static unsigned short root_swap = 0xffff;
182 struct block_device *hib_resume_bdev;
188 static int mark_swapfiles(struct swap_map_handle *handle, unsigned int flags)
192 hib_bio_read_page(swsusp_resume_block, swsusp_header, NULL);
193 if (!memcmp("SWAP-SPACE",swsusp_header->sig, 10) ||
194 !memcmp("SWAPSPACE2",swsusp_header->sig, 10)) {
195 memcpy(swsusp_header->orig_sig,swsusp_header->sig, 10);
196 memcpy(swsusp_header->sig,SWSUSP_SIG, 10);
197 swsusp_header->image = handle->first_sector;
198 swsusp_header->flags = flags;
199 error = hib_bio_write_page(swsusp_resume_block,
200 swsusp_header, NULL);
202 printk(KERN_ERR "PM: Swap header not found!\n");
209 * swsusp_swap_check - check if the resume device is a swap device
210 * and get its index (if so)
213 static int swsusp_swap_check(void) /* This is called before saving image */
217 res = swap_type_of(swsusp_resume_device, swsusp_resume_block,
223 res = blkdev_get(hib_resume_bdev, FMODE_WRITE);
227 res = set_blocksize(hib_resume_bdev, PAGE_SIZE);
229 blkdev_put(hib_resume_bdev, FMODE_WRITE);
235 * write_page - Write one page to given swap location.
236 * @buf: Address we're writing.
237 * @offset: Offset of the swap page we're writing to.
238 * @bio_chain: Link the next write BIO here
241 static int write_page(void *buf, sector_t offset, struct bio **bio_chain)
249 src = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
251 memcpy(src, buf, PAGE_SIZE);
254 bio_chain = NULL; /* Go synchronous */
260 return hib_bio_write_page(offset, src, bio_chain);
263 static void release_swap_writer(struct swap_map_handle *handle)
266 free_page((unsigned long)handle->cur);
270 static int get_swap_writer(struct swap_map_handle *handle)
272 handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
275 handle->cur_swap = alloc_swapdev_block(root_swap);
276 if (!handle->cur_swap) {
277 release_swap_writer(handle);
281 handle->first_sector = handle->cur_swap;
285 static int swap_write_page(struct swap_map_handle *handle, void *buf,
286 struct bio **bio_chain)
293 offset = alloc_swapdev_block(root_swap);
294 error = write_page(buf, offset, bio_chain);
297 handle->cur->entries[handle->k++] = offset;
298 if (handle->k >= MAP_PAGE_ENTRIES) {
299 error = hib_wait_on_bio_chain(bio_chain);
302 offset = alloc_swapdev_block(root_swap);
305 handle->cur->next_swap = offset;
306 error = write_page(handle->cur, handle->cur_swap, NULL);
309 memset(handle->cur, 0, PAGE_SIZE);
310 handle->cur_swap = offset;
317 static int flush_swap_writer(struct swap_map_handle *handle)
319 if (handle->cur && handle->cur_swap)
320 return write_page(handle->cur, handle->cur_swap, NULL);
326 * save_image - save the suspend image data
329 static int save_image(struct swap_map_handle *handle,
330 struct snapshot_handle *snapshot,
331 unsigned int nr_to_write)
338 struct timeval start;
341 printk(KERN_INFO "PM: Saving image data pages (%u pages) ... ",
343 m = nr_to_write / 100;
348 do_gettimeofday(&start);
350 ret = snapshot_read_next(snapshot);
353 ret = swap_write_page(handle, data_of(*snapshot), &bio);
357 printk(KERN_CONT "\b\b\b\b%3d%%", nr_pages / m);
360 err2 = hib_wait_on_bio_chain(&bio);
361 do_gettimeofday(&stop);
365 printk(KERN_CONT "\b\b\b\bdone\n");
367 printk(KERN_CONT "\n");
368 swsusp_show_speed(&start, &stop, nr_to_write, "Wrote");
373 * enough_swap - Make sure we have enough swap to save the image.
375 * Returns TRUE or FALSE after checking the total amount of swap
376 * space avaiable from the resume partition.
379 static int enough_swap(unsigned int nr_pages)
381 unsigned int free_swap = count_swap_pages(root_swap, 1);
383 pr_debug("PM: Free swap pages: %u\n", free_swap);
384 return free_swap > nr_pages + PAGES_FOR_IO;
388 * swsusp_write - Write entire image and metadata.
389 * @flags: flags to pass to the "boot" kernel in the image header
391 * It is important _NOT_ to umount filesystems at this point. We want
392 * them synced (in case something goes wrong) but we DO not want to mark
393 * filesystem clean: it is not. (And it does not matter, if we resume
394 * correctly, we'll mark system clean, anyway.)
397 int swsusp_write(unsigned int flags)
399 struct swap_map_handle handle;
400 struct snapshot_handle snapshot;
401 struct swsusp_info *header;
404 error = swsusp_swap_check();
406 printk(KERN_ERR "PM: Cannot find swap device, try "
410 memset(&snapshot, 0, sizeof(struct snapshot_handle));
411 error = snapshot_read_next(&snapshot);
412 if (error < PAGE_SIZE) {
418 header = (struct swsusp_info *)data_of(snapshot);
419 if (!enough_swap(header->pages)) {
420 printk(KERN_ERR "PM: Not enough free swap\n");
424 error = get_swap_writer(&handle);
426 error = swap_write_page(&handle, header, NULL);
428 error = save_image(&handle, &snapshot,
432 flush_swap_writer(&handle);
433 printk(KERN_INFO "PM: S");
434 error = mark_swapfiles(&handle, flags);
439 free_all_swap_pages(root_swap);
441 release_swap_writer(&handle);
443 swsusp_close(FMODE_WRITE);
448 * The following functions allow us to read data using a swap map
449 * in a file-alike way
452 static void release_swap_reader(struct swap_map_handle *handle)
455 free_page((unsigned long)handle->cur);
459 static int get_swap_reader(struct swap_map_handle *handle, sector_t start)
466 handle->cur = (struct swap_map_page *)get_zeroed_page(__GFP_WAIT | __GFP_HIGH);
470 error = hib_bio_read_page(start, handle->cur, NULL);
472 release_swap_reader(handle);
479 static int swap_read_page(struct swap_map_handle *handle, void *buf,
480 struct bio **bio_chain)
487 offset = handle->cur->entries[handle->k];
490 error = hib_bio_read_page(offset, buf, bio_chain);
493 if (++handle->k >= MAP_PAGE_ENTRIES) {
494 error = hib_wait_on_bio_chain(bio_chain);
496 offset = handle->cur->next_swap;
498 release_swap_reader(handle);
500 error = hib_bio_read_page(offset, handle->cur, NULL);
506 * load_image - load the image using the swap map handle
507 * @handle and the snapshot handle @snapshot
508 * (assume there are @nr_pages pages to load)
511 static int load_image(struct swap_map_handle *handle,
512 struct snapshot_handle *snapshot,
513 unsigned int nr_to_read)
517 struct timeval start;
523 printk(KERN_INFO "PM: Loading image data pages (%u pages) ... ",
525 m = nr_to_read / 100;
530 do_gettimeofday(&start);
532 error = snapshot_write_next(snapshot);
535 error = swap_read_page(handle, data_of(*snapshot), &bio);
538 if (snapshot->sync_read)
539 error = hib_wait_on_bio_chain(&bio);
543 printk("\b\b\b\b%3d%%", nr_pages / m);
546 err2 = hib_wait_on_bio_chain(&bio);
547 do_gettimeofday(&stop);
551 printk("\b\b\b\bdone\n");
552 snapshot_write_finalize(snapshot);
553 if (!snapshot_image_loaded(snapshot))
557 swsusp_show_speed(&start, &stop, nr_to_read, "Read");
562 * swsusp_read - read the hibernation image.
563 * @flags_p: flags passed by the "frozen" kernel in the image header should
564 * be written into this memeory location
567 int swsusp_read(unsigned int *flags_p)
570 struct swap_map_handle handle;
571 struct snapshot_handle snapshot;
572 struct swsusp_info *header;
574 *flags_p = swsusp_header->flags;
576 memset(&snapshot, 0, sizeof(struct snapshot_handle));
577 error = snapshot_write_next(&snapshot);
578 if (error < PAGE_SIZE)
579 return error < 0 ? error : -EFAULT;
580 header = (struct swsusp_info *)data_of(snapshot);
581 error = get_swap_reader(&handle, swsusp_header->image);
583 error = swap_read_page(&handle, header, NULL);
585 error = load_image(&handle, &snapshot, header->pages - 1);
586 release_swap_reader(&handle);
589 pr_debug("PM: Image successfully loaded\n");
591 pr_debug("PM: Error %d resuming\n", error);
596 * swsusp_check - Check for swsusp signature in the resume device
599 int swsusp_check(void)
603 hib_resume_bdev = open_by_devnum(swsusp_resume_device, FMODE_READ);
604 if (!IS_ERR(hib_resume_bdev)) {
605 set_blocksize(hib_resume_bdev, PAGE_SIZE);
606 memset(swsusp_header, 0, PAGE_SIZE);
607 error = hib_bio_read_page(swsusp_resume_block,
608 swsusp_header, NULL);
612 if (!memcmp(SWSUSP_SIG, swsusp_header->sig, 10)) {
613 memcpy(swsusp_header->sig, swsusp_header->orig_sig, 10);
614 /* Reset swap signature now */
615 error = hib_bio_write_page(swsusp_resume_block,
616 swsusp_header, NULL);
623 blkdev_put(hib_resume_bdev, FMODE_READ);
625 pr_debug("PM: Signature found, resuming\n");
627 error = PTR_ERR(hib_resume_bdev);
631 pr_debug("PM: Error %d checking image file\n", error);
637 * swsusp_close - close swap device.
640 void swsusp_close(fmode_t mode)
642 if (IS_ERR(hib_resume_bdev)) {
643 pr_debug("PM: Image device not initialised\n");
647 blkdev_put(hib_resume_bdev, mode);
650 static int swsusp_header_init(void)
652 swsusp_header = (struct swsusp_header*) __get_free_page(GFP_KERNEL);
654 panic("Could not allocate memory for swsusp_header\n");
658 core_initcall(swsusp_header_init);