[PATCH] swsusp: use block device offsets to identify swap locations

Make swsusp use block device offsets instead of swap offsets to identify swap
locations and make it use the same code paths for writing as well as for
reading data.

This allows us to use the same code for handling swap files and swap
partitions and to simplify the code, eg.  by dropping rw_swap_page_sync().

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>

1 files changed, 70 insertions, 63 deletions

diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index 7768c2ba7550..1b08f46bbb7e 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -34,8 +34,8 @@ extern char resume_file[];
 #define SWSUSP_SIG      "S1SUSPEND"
 
 static struct swsusp_header {
-        char reserved[PAGE_SIZE - 20 - sizeof(swp_entry_t)];
-        swp_entry_t image;
+        char reserved[PAGE_SIZE - 20 - sizeof(sector_t)];
+        sector_t image;
         char    orig_sig[10];
         char    sig[10];
 } __attribute__((packed, aligned(PAGE_SIZE))) swsusp_header;
@@ -100,9 +100,9 @@ static int bio_read_page(pgoff_t page_off, void *addr, struct bio **bio_chain)
         return submit(READ, page_off, virt_to_page(addr), bio_chain);
 }
 
-static int bio_write_page(pgoff_t page_off, void *addr)
+static int bio_write_page(pgoff_t page_off, void *addr, struct bio **bio_chain)
 {
-        return submit(WRITE, page_off, virt_to_page(addr), NULL);
+        return submit(WRITE, page_off, virt_to_page(addr), bio_chain);
 }
 
 static int wait_on_bio_chain(struct bio **bio_chain)
@@ -157,22 +157,19 @@ static void show_speed(struct timeval *start, struct timeval *stop,
  * Saving part
  */
 
-static int mark_swapfiles(swp_entry_t start)
+static int mark_swapfiles(sector_t start)
 {
         int error;
 
-        rw_swap_page_sync(READ, swp_entry(root_swap, 0),
-                          virt_to_page((unsigned long)&swsusp_header), NULL);
+        bio_read_page(0, &swsusp_header, NULL);
         if (!memcmp("SWAP-SPACE",swsusp_header.sig, 10) ||
             !memcmp("SWAPSPACE2",swsusp_header.sig, 10)) {
                 memcpy(swsusp_header.orig_sig,swsusp_header.sig, 10);
                 memcpy(swsusp_header.sig,SWSUSP_SIG, 10);
                 swsusp_header.image = start;
-                error = rw_swap_page_sync(WRITE, swp_entry(root_swap, 0),
-                                virt_to_page((unsigned long)&swsusp_header),
-                                NULL);
+                error = bio_write_page(0, &swsusp_header, NULL);
         } else {
-                pr_debug("swsusp: Partition is not swap space.\n");
+                printk(KERN_ERR "swsusp: Swap header not found!\n");
                 error = -ENODEV;
         }
         return error;
@@ -185,12 +182,21 @@ static int mark_swapfiles(swp_entry_t start)
 
 static int swsusp_swap_check(void) /* This is called before saving image */
 {
-        int res = swap_type_of(swsusp_resume_device, 0);
+        int res;
+
+        res = swap_type_of(swsusp_resume_device, 0);
+        if (res < 0)
+                return res;
+
+        root_swap = res;
+        resume_bdev = open_by_devnum(swsusp_resume_device, FMODE_WRITE);
+        if (IS_ERR(resume_bdev))
+                return PTR_ERR(resume_bdev);
+
+        res = set_blocksize(resume_bdev, PAGE_SIZE);
+        if (res < 0)
+                blkdev_put(resume_bdev);
 
-        if (res >= 0) {
-                root_swap = res;
-                return 0;
-        }
         return res;
 }
 
@@ -201,36 +207,26 @@ static int swsusp_swap_check(void) /* This is called before saving image */
  *      @bio_chain:     Link the next write BIO here
  */
 
-static int write_page(void *buf, unsigned long offset, struct bio **bio_chain)
+static int write_page(void *buf, sector_t offset, struct bio **bio_chain)
 {
-        swp_entry_t entry;
-        int error = -ENOSPC;
-
-        if (offset) {
-                struct page *page = virt_to_page(buf);
-
-                if (bio_chain) {
-                        /*
-                         * Whether or not we successfully allocated a copy page,
-                         * we take a ref on the page here.  It gets undone in
-                         * wait_on_bio_chain().
-                         */
-                        struct page *page_copy;
-                        page_copy = alloc_page(GFP_ATOMIC);
-                        if (page_copy == NULL) {
-                                WARN_ON_ONCE(1);
-                                bio_chain = NULL;       /* Go synchronous */
-                                get_page(page);
-                        } else {
-                                memcpy(page_address(page_copy),
-                                        page_address(page), PAGE_SIZE);
-                                page = page_copy;
-                        }
+        void *src;
+
+        if (!offset)
+                return -ENOSPC;
+
+        if (bio_chain) {
+                src = (void *)__get_free_page(GFP_ATOMIC);
+                if (src) {
+                        memcpy(src, buf, PAGE_SIZE);
+                } else {
+                        WARN_ON_ONCE(1);
+                        bio_chain = NULL;       /* Go synchronous */
+                        src = buf;
                 }
-                entry = swp_entry(root_swap, offset);
-                error = rw_swap_page_sync(WRITE, entry, page, bio_chain);
+        } else {
+                src = buf;
         }
-        return error;
+        return bio_write_page(offset, src, bio_chain);
 }
 
 /*
@@ -248,11 +244,11 @@ static int write_page(void *buf, unsigned long offset, struct bio **bio_chain)
  *      at a time.
  */
 
-#define MAP_PAGE_ENTRIES        (PAGE_SIZE / sizeof(long) - 1)
+#define MAP_PAGE_ENTRIES        (PAGE_SIZE / sizeof(sector_t) - 1)
 
 struct swap_map_page {
-        unsigned long           entries[MAP_PAGE_ENTRIES];
-        unsigned long           next_swap;
+        sector_t entries[MAP_PAGE_ENTRIES];
+        sector_t next_swap;
 };
 
 /**
@@ -262,7 +258,7 @@ struct swap_map_page {
 
 struct swap_map_handle {
         struct swap_map_page *cur;
-        unsigned long cur_swap;
+        sector_t cur_swap;
         struct bitmap_page *bitmap;
         unsigned int k;
 };
@@ -287,7 +283,7 @@ static int get_swap_writer(struct swap_map_handle *handle)
                 release_swap_writer(handle);
                 return -ENOMEM;
         }
-        handle->cur_swap = alloc_swap_page(root_swap, handle->bitmap);
+        handle->cur_swap = alloc_swapdev_block(root_swap, handle->bitmap);
         if (!handle->cur_swap) {
                 release_swap_writer(handle);
                 return -ENOSPC;
@@ -300,11 +296,11 @@ static int swap_write_page(struct swap_map_handle *handle, void *buf,
                                 struct bio **bio_chain)
 {
         int error = 0;
-        unsigned long offset;
+        sector_t offset;
 
         if (!handle->cur)
                 return -EINVAL;
-        offset = alloc_swap_page(root_swap, handle->bitmap);
+        offset = alloc_swapdev_block(root_swap, handle->bitmap);
         error = write_page(buf, offset, bio_chain);
         if (error)
                 return error;
@@ -313,7 +309,7 @@ static int swap_write_page(struct swap_map_handle *handle, void *buf,
                 error = wait_on_bio_chain(bio_chain);
                 if (error)
                         goto out;
-                offset = alloc_swap_page(root_swap, handle->bitmap);
+                offset = alloc_swapdev_block(root_swap, handle->bitmap);
                 if (!offset)
                         return -ENOSPC;
                 handle->cur->next_swap = offset;
@@ -413,37 +409,47 @@ int swsusp_write(void)
         struct swsusp_info *header;
         int error;
 
-        if ((error = swsusp_swap_check())) {
+        error = swsusp_swap_check();
+        if (error) {
                 printk(KERN_ERR "swsusp: Cannot find swap device, try "
                                 "swapon -a.\n");
                 return error;
         }
         memset(&snapshot, 0, sizeof(struct snapshot_handle));
         error = snapshot_read_next(&snapshot, PAGE_SIZE);
-        if (error < PAGE_SIZE)
-                return error < 0 ? error : -EFAULT;
+        if (error < PAGE_SIZE) {
+                if (error >= 0)
+                        error = -EFAULT;
+
+                goto out;
+        }
         header = (struct swsusp_info *)data_of(snapshot);
         if (!enough_swap(header->pages)) {
                 printk(KERN_ERR "swsusp: Not enough free swap\n");
-                return -ENOSPC;
+                error = -ENOSPC;
+                goto out;
         }
         error = get_swap_writer(&handle);
         if (!error) {
-                unsigned long start = handle.cur_swap;
+                sector_t start = handle.cur_swap;
+
                 error = swap_write_page(&handle, header, NULL);
                 if (!error)
                         error = save_image(&handle, &snapshot,
                                         header->pages - 1);
+
                 if (!error) {
                         flush_swap_writer(&handle);
                         printk("S");
-                        error = mark_swapfiles(swp_entry(root_swap, start));
+                        error = mark_swapfiles(start);
                         printk("|\n");
                 }
         }
         if (error)
                 free_all_swap_pages(root_swap, handle.bitmap);
         release_swap_writer(&handle);
+out:
+        swsusp_close();
         return error;
 }
 
@@ -459,17 +465,18 @@ static void release_swap_reader(struct swap_map_handle *handle)
         handle->cur = NULL;
 }
 
-static int get_swap_reader(struct swap_map_handle *handle,
-                                      swp_entry_t start)
+static int get_swap_reader(struct swap_map_handle *handle, sector_t start)
 {
         int error;
 
-        if (!swp_offset(start))
+        if (!start)
                 return -EINVAL;
+
         handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_ATOMIC);
         if (!handle->cur)
                 return -ENOMEM;
-        error = bio_read_page(swp_offset(start), handle->cur, NULL);
+
+        error = bio_read_page(start, handle->cur, NULL);
         if (error) {
                 release_swap_reader(handle);
                 return error;
@@ -481,7 +488,7 @@ static int get_swap_reader(struct swap_map_handle *handle,
 static int swap_read_page(struct swap_map_handle *handle, void *buf,
                                 struct bio **bio_chain)
 {
-        unsigned long offset;
+        sector_t offset;
         int error;
 
         if (!handle->cur)
@@ -608,7 +615,7 @@ int swsusp_check(void)
                 if (!memcmp(SWSUSP_SIG, swsusp_header.sig, 10)) {
                         memcpy(swsusp_header.sig, swsusp_header.orig_sig, 10);
                         /* Reset swap signature now */
-                        error = bio_write_page(0, &swsusp_header);
+                        error = bio_write_page(0, &swsusp_header, NULL);
                 } else {
                         return -EINVAL;
                 }