err.no Git - linux-2.6/blob - kernel/power/swsusp.c

   1 /*
   2  * linux/kernel/power/swsusp.c
   3  *
   4  * This file provides code to write suspend image to swap and read it back.
   5  *
   6  * Copyright (C) 1998-2001 Gabor Kuti <seasons@fornax.hu>
   7  * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@suse.cz>
   8  *
   9  * This file is released under the GPLv2.
  10  *
  11  * I'd like to thank the following people for their work:
  12  *
  13  * Pavel Machek <pavel@ucw.cz>:
  14  * Modifications, defectiveness pointing, being with me at the very beginning,
  15  * suspend to swap space, stop all tasks. Port to 2.4.18-ac and 2.5.17.
  16  *
  17  * Steve Doddi <dirk@loth.demon.co.uk>:
  18  * Support the possibility of hardware state restoring.
  19  *
  20  * Raph <grey.havens@earthling.net>:
  21  * Support for preserving states of network devices and virtual console
  22  * (including X and svgatextmode)
  23  *
  24  * Kurt Garloff <garloff@suse.de>:
  25  * Straightened the critical function in order to prevent compilers from
  26  * playing tricks with local variables.
  27  *
  28  * Andreas Mohr <a.mohr@mailto.de>
  29  *
  30  * Alex Badea <vampire@go.ro>:
  31  * Fixed runaway init
  32  *
  33  * Rafael J. Wysocki <rjw@sisk.pl>
  34  * Added the swap map data structure and reworked the handling of swap
  35  *
  36  * More state savers are welcome. Especially for the scsi layer...
  37  *
  38  * For TODOs,FIXMEs also look in Documentation/power/swsusp.txt
  39  */
  40
  41 #include <linux/module.h>
  42 #include <linux/mm.h>
  43 #include <linux/suspend.h>
  44 #include <linux/smp_lock.h>
  45 #include <linux/file.h>
  46 #include <linux/utsname.h>
  47 #include <linux/version.h>
  48 #include <linux/delay.h>
  49 #include <linux/bitops.h>
  50 #include <linux/spinlock.h>
  51 #include <linux/genhd.h>
  52 #include <linux/kernel.h>
  53 #include <linux/major.h>
  54 #include <linux/swap.h>
  55 #include <linux/pm.h>
  56 #include <linux/device.h>
  57 #include <linux/buffer_head.h>
  58 #include <linux/swapops.h>
  59 #include <linux/bootmem.h>
  60 #include <linux/syscalls.h>
  61 #include <linux/highmem.h>
  62 #include <linux/bio.h>
  63
  64 #include <asm/uaccess.h>
  65 #include <asm/mmu_context.h>
  66 #include <asm/pgtable.h>
  67 #include <asm/tlbflush.h>
  68 #include <asm/io.h>
  69
  70 #include "power.h"
  71
  72 /*
  73  * Preferred image size in bytes (tunable via /sys/power/image_size).
  74  * When it is set to N, swsusp will do its best to ensure the image
  75  * size will not exceed N bytes, but if that is impossible, it will
  76  * try to create the smallest image possible.
  77  */
  78 unsigned long image_size = 500 * 1024 * 1024;
  79
  80 int in_suspend __nosavedata = 0;
  81
  82 #ifdef CONFIG_HIGHMEM
  83 unsigned int count_highmem_pages(void);
  84 int save_highmem(void);
  85 int restore_highmem(void);
  86 #else
  87 static int save_highmem(void) { return 0; }
  88 static int restore_highmem(void) { return 0; }
  89 static unsigned int count_highmem_pages(void) { return 0; }
  90 #endif
  91
  92 extern char resume_file[];
  93
  94 #define SWSUSP_SIG      "S1SUSPEND"
  95
  96 static struct swsusp_header {
  97         char reserved[PAGE_SIZE - 20 - sizeof(swp_entry_t)];
  98         swp_entry_t image;
  99         char    orig_sig[10];
 100         char    sig[10];
 101 } __attribute__((packed, aligned(PAGE_SIZE))) swsusp_header;
 102
 103 /*
 104  * Saving part...
 105  */
 106
 107 static unsigned short root_swap = 0xffff;
 108
 109 static int mark_swapfiles(swp_entry_t start)
 110 {
 111         int error;
 112
 113         rw_swap_page_sync(READ,
 114                           swp_entry(root_swap, 0),
 115                           virt_to_page((unsigned long)&swsusp_header));
 116         if (!memcmp("SWAP-SPACE",swsusp_header.sig, 10) ||
 117             !memcmp("SWAPSPACE2",swsusp_header.sig, 10)) {
 118                 memcpy(swsusp_header.orig_sig,swsusp_header.sig, 10);
 119                 memcpy(swsusp_header.sig,SWSUSP_SIG, 10);
 120                 swsusp_header.image = start;
 121                 error = rw_swap_page_sync(WRITE,
 122                                           swp_entry(root_swap, 0),
 123                                           virt_to_page((unsigned long)
 124                                                        &swsusp_header));
 125         } else {
 126                 pr_debug("swsusp: Partition is not swap space.\n");
 127                 error = -ENODEV;
 128         }
 129         return error;
 130 }
 131
 132 /**
 133  *      swsusp_swap_check - check if the resume device is a swap device
 134  *      and get its index (if so)
 135  */
 136
 137 static int swsusp_swap_check(void) /* This is called before saving image */
 138 {
 139         int res = swap_type_of(swsusp_resume_device);
 140
 141         if (res >= 0) {
 142                 root_swap = res;
 143                 return 0;
 144         }
 145         return res;
 146 }
 147
 148 /**
 149  *      The bitmap is used for tracing allocated swap pages
 150  *
 151  *      The entire bitmap consists of a number of bitmap_page
 152  *      structures linked with the help of the .next member.
 153  *      Thus each page can be allocated individually, so we only
 154  *      need to make 0-order memory allocations to create
 155  *      the bitmap.
 156  */
 157
 158 #define BITMAP_PAGE_SIZE        (PAGE_SIZE - sizeof(void *))
 159 #define BITMAP_PAGE_CHUNKS      (BITMAP_PAGE_SIZE / sizeof(long))
 160 #define BITS_PER_CHUNK          (sizeof(long) * 8)
 161 #define BITMAP_PAGE_BITS        (BITMAP_PAGE_CHUNKS * BITS_PER_CHUNK)
 162
 163 struct bitmap_page {
 164         unsigned long           chunks[BITMAP_PAGE_CHUNKS];
 165         struct bitmap_page      *next;
 166 };
 167
 168 /**
 169  *      The following functions are used for tracing the allocated
 170  *      swap pages, so that they can be freed in case of an error.
 171  *
 172  *      The functions operate on a linked bitmap structure defined
 173  *      above
 174  */
 175
 176 static void free_bitmap(struct bitmap_page *bitmap)
 177 {
 178         struct bitmap_page *bp;
 179
 180         while (bitmap) {
 181                 bp = bitmap->next;
 182                 free_page((unsigned long)bitmap);
 183                 bitmap = bp;
 184         }
 185 }
 186
 187 static struct bitmap_page *alloc_bitmap(unsigned int nr_bits)
 188 {
 189         struct bitmap_page *bitmap, *bp;
 190         unsigned int n;
 191
 192         if (!nr_bits)
 193                 return NULL;
 194
 195         bitmap = (struct bitmap_page *)get_zeroed_page(GFP_KERNEL);
 196         bp = bitmap;
 197         for (n = BITMAP_PAGE_BITS; n < nr_bits; n += BITMAP_PAGE_BITS) {
 198                 bp->next = (struct bitmap_page *)get_zeroed_page(GFP_KERNEL);
 199                 bp = bp->next;
 200                 if (!bp) {
 201                         free_bitmap(bitmap);
 202                         return NULL;
 203                 }
 204         }
 205         return bitmap;
 206 }
 207
 208 static int bitmap_set(struct bitmap_page *bitmap, unsigned long bit)
 209 {
 210         unsigned int n;
 211
 212         n = BITMAP_PAGE_BITS;
 213         while (bitmap && n <= bit) {
 214                 n += BITMAP_PAGE_BITS;
 215                 bitmap = bitmap->next;
 216         }
 217         if (!bitmap)
 218                 return -EINVAL;
 219         n -= BITMAP_PAGE_BITS;
 220         bit -= n;
 221         n = 0;
 222         while (bit >= BITS_PER_CHUNK) {
 223                 bit -= BITS_PER_CHUNK;
 224                 n++;
 225         }
 226         bitmap->chunks[n] |= (1UL << bit);
 227         return 0;
 228 }
 229
 230 static unsigned long alloc_swap_page(int swap, struct bitmap_page *bitmap)
 231 {
 232         unsigned long offset;
 233
 234         offset = swp_offset(get_swap_page_of_type(swap));
 235         if (offset) {
 236                 if (bitmap_set(bitmap, offset)) {
 237                         swap_free(swp_entry(swap, offset));
 238                         offset = 0;
 239                 }
 240         }
 241         return offset;
 242 }
 243
 244 static void free_all_swap_pages(int swap, struct bitmap_page *bitmap)
 245 {
 246         unsigned int bit, n;
 247         unsigned long test;
 248
 249         bit = 0;
 250         while (bitmap) {
 251                 for (n = 0; n < BITMAP_PAGE_CHUNKS; n++)
 252                         for (test = 1UL; test; test <<= 1) {
 253                                 if (bitmap->chunks[n] & test)
 254                                         swap_free(swp_entry(swap, bit));
 255                                 bit++;
 256                         }
 257                 bitmap = bitmap->next;
 258         }
 259 }
 260
 261 /**
 262  *      write_page - Write one page to given swap location.
 263  *      @buf:           Address we're writing.
 264  *      @offset:        Offset of the swap page we're writing to.
 265  */
 266
 267 static int write_page(void *buf, unsigned long offset)
 268 {
 269         swp_entry_t entry;
 270         int error = -ENOSPC;
 271
 272         if (offset) {
 273                 entry = swp_entry(root_swap, offset);
 274                 error = rw_swap_page_sync(WRITE, entry, virt_to_page(buf));
 275         }
 276         return error;
 277 }
 278
 279 /*
 280  *      The swap map is a data structure used for keeping track of each page
 281  *      written to a swap partition.  It consists of many swap_map_page
 282  *      structures that contain each an array of MAP_PAGE_SIZE swap entries.
 283  *      These structures are stored on the swap and linked together with the
 284  *      help of the .next_swap member.
 285  *
 286  *      The swap map is created during suspend.  The swap map pages are
 287  *      allocated and populated one at a time, so we only need one memory
 288  *      page to set up the entire structure.
 289  *
 290  *      During resume we also only need to use one swap_map_page structure
 291  *      at a time.
 292  */
 293
 294 #define MAP_PAGE_ENTRIES        (PAGE_SIZE / sizeof(long) - 1)
 295
 296 struct swap_map_page {
 297         unsigned long           entries[MAP_PAGE_ENTRIES];
 298         unsigned long           next_swap;
 299 };
 300
 301 /**
 302  *      The swap_map_handle structure is used for handling swap in
 303  *      a file-alike way
 304  */
 305
 306 struct swap_map_handle {
 307         struct swap_map_page *cur;
 308         unsigned long cur_swap;
 309         struct bitmap_page *bitmap;
 310         unsigned int k;
 311 };
 312
 313 static void release_swap_writer(struct swap_map_handle *handle)
 314 {
 315         if (handle->cur)
 316                 free_page((unsigned long)handle->cur);
 317         handle->cur = NULL;
 318         if (handle->bitmap)
 319                 free_bitmap(handle->bitmap);
 320         handle->bitmap = NULL;
 321 }
 322
 323 static int get_swap_writer(struct swap_map_handle *handle)
 324 {
 325         handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
 326         if (!handle->cur)
 327                 return -ENOMEM;
 328         handle->bitmap = alloc_bitmap(count_swap_pages(root_swap, 0));
 329         if (!handle->bitmap) {
 330                 release_swap_writer(handle);
 331                 return -ENOMEM;
 332         }
 333         handle->cur_swap = alloc_swap_page(root_swap, handle->bitmap);
 334         if (!handle->cur_swap) {
 335                 release_swap_writer(handle);
 336                 return -ENOSPC;
 337         }
 338         handle->k = 0;
 339         return 0;
 340 }
 341
 342 static int swap_write_page(struct swap_map_handle *handle, void *buf)
 343 {
 344         int error;
 345         unsigned long offset;
 346
 347         if (!handle->cur)
 348                 return -EINVAL;
 349         offset = alloc_swap_page(root_swap, handle->bitmap);
 350         error = write_page(buf, offset);
 351         if (error)
 352                 return error;
 353         handle->cur->entries[handle->k++] = offset;
 354         if (handle->k >= MAP_PAGE_ENTRIES) {
 355                 offset = alloc_swap_page(root_swap, handle->bitmap);
 356                 if (!offset)
 357                         return -ENOSPC;
 358                 handle->cur->next_swap = offset;
 359                 error = write_page(handle->cur, handle->cur_swap);
 360                 if (error)
 361                         return error;
 362                 memset(handle->cur, 0, PAGE_SIZE);
 363                 handle->cur_swap = offset;
 364                 handle->k = 0;
 365         }
 366         return 0;
 367 }
 368
 369 static int flush_swap_writer(struct swap_map_handle *handle)
 370 {
 371         if (handle->cur && handle->cur_swap)
 372                 return write_page(handle->cur, handle->cur_swap);
 373         else
 374                 return -EINVAL;
 375 }
 376
 377 /**
 378  *      save_image - save the suspend image data
 379  */
 380
 381 static int save_image(struct swap_map_handle *handle,
 382                       struct snapshot_handle *snapshot,
 383                       unsigned int nr_pages)
 384 {
 385         unsigned int m;
 386         int ret;
 387         int error = 0;
 388
 389         printk("Saving image data pages (%u pages) ...     ", nr_pages);
 390         m = nr_pages / 100;
 391         if (!m)
 392                 m = 1;
 393         nr_pages = 0;
 394         do {
 395                 ret = snapshot_read_next(snapshot, PAGE_SIZE);
 396                 if (ret > 0) {
 397                         error = swap_write_page(handle, data_of(*snapshot));
 398                         if (error)
 399                                 break;
 400                         if (!(nr_pages % m))
 401                                 printk("\b\b\b\b%3d%%", nr_pages / m);
 402                         nr_pages++;
 403                 }
 404         } while (ret > 0);
 405         if (!error)
 406                 printk("\b\b\b\bdone\n");
 407         return error;
 408 }
 409
 410 /**
 411  *      enough_swap - Make sure we have enough swap to save the image.
 412  *
 413  *      Returns TRUE or FALSE after checking the total amount of swap
 414  *      space avaiable from the resume partition.
 415  */
 416
 417 static int enough_swap(unsigned int nr_pages)
 418 {
 419         unsigned int free_swap = count_swap_pages(root_swap, 1);
 420
 421         pr_debug("swsusp: free swap pages: %u\n", free_swap);
 422         return free_swap > (nr_pages + PAGES_FOR_IO +
 423                 (nr_pages + PBES_PER_PAGE - 1) / PBES_PER_PAGE);
 424 }
 425
 426 /**
 427  *      swsusp_write - Write entire image and metadata.
 428  *
 429  *      It is important _NOT_ to umount filesystems at this point. We want
 430  *      them synced (in case something goes wrong) but we DO not want to mark
 431  *      filesystem clean: it is not. (And it does not matter, if we resume
 432  *      correctly, we'll mark system clean, anyway.)
 433  */
 434
 435 int swsusp_write(void)
 436 {
 437         struct swap_map_handle handle;
 438         struct snapshot_handle snapshot;
 439         struct swsusp_info *header;
 440         unsigned long start;
 441         int error;
 442
 443         if ((error = swsusp_swap_check())) {
 444                 printk(KERN_ERR "swsusp: Cannot find swap device, try swapon -a.\n");
 445                 return error;
 446         }
 447         memset(&snapshot, 0, sizeof(struct snapshot_handle));
 448         error = snapshot_read_next(&snapshot, PAGE_SIZE);
 449         if (error < PAGE_SIZE)
 450                 return error < 0 ? error : -EFAULT;
 451         header = (struct swsusp_info *)data_of(snapshot);
 452         if (!enough_swap(header->pages)) {
 453                 printk(KERN_ERR "swsusp: Not enough free swap\n");
 454                 return -ENOSPC;
 455         }
 456         error = get_swap_writer(&handle);
 457         if (!error) {
 458                 start = handle.cur_swap;
 459                 error = swap_write_page(&handle, header);
 460         }
 461         if (!error)
 462                 error = save_image(&handle, &snapshot, header->pages - 1);
 463         if (!error) {
 464                 flush_swap_writer(&handle);
 465                 printk("S");
 466                 error = mark_swapfiles(swp_entry(root_swap, start));
 467                 printk("|\n");
 468         }
 469         if (error)
 470                 free_all_swap_pages(root_swap, handle.bitmap);
 471         release_swap_writer(&handle);
 472         return error;
 473 }
 474
 475 /**
 476  *      swsusp_shrink_memory -  Try to free as much memory as needed
 477  *
 478  *      ... but do not OOM-kill anyone
 479  *
 480  *      Notice: all userland should be stopped before it is called, or
 481  *      livelock is possible.
 482  */
 483
 484 #define SHRINK_BITE     10000
 485
 486 int swsusp_shrink_memory(void)
 487 {
 488         long size, tmp;
 489         struct zone *zone;
 490         unsigned long pages = 0;
 491         unsigned int i = 0;
 492         char *p = "-\\|/";
 493
 494         printk("Shrinking memory...  ");
 495         do {
 496                 size = 2 * count_highmem_pages();
 497                 size += size / 50 + count_data_pages();
 498                 size += (size + PBES_PER_PAGE - 1) / PBES_PER_PAGE +
 499                         PAGES_FOR_IO;
 500                 tmp = size;
 501                 for_each_zone (zone)
 502                         if (!is_highmem(zone))
 503                                 tmp -= zone->free_pages;
 504                 if (tmp > 0) {
 505                         tmp = shrink_all_memory(SHRINK_BITE);
 506                         if (!tmp)
 507                                 return -ENOMEM;
 508                         pages += tmp;
 509                 } else if (size > image_size / PAGE_SIZE) {
 510                         tmp = shrink_all_memory(SHRINK_BITE);
 511                         pages += tmp;
 512                 }
 513                 printk("\b%c", p[i++%4]);
 514         } while (tmp > 0);
 515         printk("\bdone (%lu pages freed)\n", pages);
 516
 517         return 0;
 518 }
 519
 520 int swsusp_suspend(void)
 521 {
 522         int error;
 523
 524         if ((error = arch_prepare_suspend()))
 525                 return error;
 526         local_irq_disable();
 527         /* At this point, device_suspend() has been called, but *not*
 528          * device_power_down(). We *must* device_power_down() now.
 529          * Otherwise, drivers for some devices (e.g. interrupt controllers)
 530          * become desynchronized with the actual state of the hardware
 531          * at resume time, and evil weirdness ensues.
 532          */
 533         if ((error = device_power_down(PMSG_FREEZE))) {
 534                 printk(KERN_ERR "Some devices failed to power down, aborting suspend\n");
 535                 goto Enable_irqs;
 536         }
 537
 538         if ((error = save_highmem())) {
 539                 printk(KERN_ERR "swsusp: Not enough free pages for highmem\n");
 540                 goto Restore_highmem;
 541         }
 542
 543         save_processor_state();
 544         if ((error = swsusp_arch_suspend()))
 545                 printk(KERN_ERR "Error %d suspending\n", error);
 546         /* Restore control flow magically appears here */
 547         restore_processor_state();
 548 Restore_highmem:
 549         restore_highmem();
 550         device_power_up();
 551 Enable_irqs:
 552         local_irq_enable();
 553         return error;
 554 }
 555
 556 int swsusp_resume(void)
 557 {
 558         int error;
 559         local_irq_disable();
 560         if (device_power_down(PMSG_FREEZE))
 561                 printk(KERN_ERR "Some devices failed to power down, very bad\n");
 562         /* We'll ignore saved state, but this gets preempt count (etc) right */
 563         save_processor_state();
 564         error = swsusp_arch_resume();
 565         /* Code below is only ever reached in case of failure. Otherwise
 566          * execution continues at place where swsusp_arch_suspend was called
 567          */
 568         BUG_ON(!error);
 569         /* The only reason why swsusp_arch_resume() can fail is memory being
 570          * very tight, so we have to free it as soon as we can to avoid
 571          * subsequent failures
 572          */
 573         swsusp_free();
 574         restore_processor_state();
 575         restore_highmem();
 576         touch_softlockup_watchdog();
 577         device_power_up();
 578         local_irq_enable();
 579         return error;
 580 }
 581
 582 /*
 583  *      Using bio to read from swap.
 584  *      This code requires a bit more work than just using buffer heads
 585  *      but, it is the recommended way for 2.5/2.6.
 586  *      The following are to signal the beginning and end of I/O. Bios
 587  *      finish asynchronously, while we want them to happen synchronously.
 588  *      A simple atomic_t, and a wait loop take care of this problem.
 589  */
 590
 591 static atomic_t io_done = ATOMIC_INIT(0);
 592
 593 static int end_io(struct bio *bio, unsigned int num, int err)
 594 {
 595         if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
 596                 panic("I/O error reading memory image");
 597         atomic_set(&io_done, 0);
 598         return 0;
 599 }
 600
 601 static struct block_device *resume_bdev;
 602
 603 /**
 604  *      submit - submit BIO request.
 605  *      @rw:    READ or WRITE.
 606  *      @off    physical offset of page.
 607  *      @page:  page we're reading or writing.
 608  *
 609  *      Straight from the textbook - allocate and initialize the bio.
 610  *      If we're writing, make sure the page is marked as dirty.
 611  *      Then submit it and wait.
 612  */
 613
 614 static int submit(int rw, pgoff_t page_off, void *page)
 615 {
 616         int error = 0;
 617         struct bio *bio;
 618
 619         bio = bio_alloc(GFP_ATOMIC, 1);
 620         if (!bio)
 621                 return -ENOMEM;
 622         bio->bi_sector = page_off * (PAGE_SIZE >> 9);
 623         bio->bi_bdev = resume_bdev;
 624         bio->bi_end_io = end_io;
 625
 626         if (bio_add_page(bio, virt_to_page(page), PAGE_SIZE, 0) < PAGE_SIZE) {
 627                 printk("swsusp: ERROR: adding page to bio at %ld\n",page_off);
 628                 error = -EFAULT;
 629                 goto Done;
 630         }
 631
 632
 633         atomic_set(&io_done, 1);
 634         submit_bio(rw | (1 << BIO_RW_SYNC), bio);
 635         while (atomic_read(&io_done))
 636                 yield();
 637         if (rw == READ)
 638                 bio_set_pages_dirty(bio);
 639  Done:
 640         bio_put(bio);
 641         return error;
 642 }
 643
 644 static int bio_read_page(pgoff_t page_off, void *page)
 645 {
 646         return submit(READ, page_off, page);
 647 }
 648
 649 static int bio_write_page(pgoff_t page_off, void *page)
 650 {
 651         return submit(WRITE, page_off, page);
 652 }
 653
 654 /**
 655  *      The following functions allow us to read data using a swap map
 656  *      in a file-alike way
 657  */
 658
 659 static void release_swap_reader(struct swap_map_handle *handle)
 660 {
 661         if (handle->cur)
 662                 free_page((unsigned long)handle->cur);
 663         handle->cur = NULL;
 664 }
 665
 666 static int get_swap_reader(struct swap_map_handle *handle,
 667                                       swp_entry_t start)
 668 {
 669         int error;
 670
 671         if (!swp_offset(start))
 672                 return -EINVAL;
 673         handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_ATOMIC);
 674         if (!handle->cur)
 675                 return -ENOMEM;
 676         error = bio_read_page(swp_offset(start), handle->cur);
 677         if (error) {
 678                 release_swap_reader(handle);
 679                 return error;
 680         }
 681         handle->k = 0;
 682         return 0;
 683 }
 684
 685 static int swap_read_page(struct swap_map_handle *handle, void *buf)
 686 {
 687         unsigned long offset;
 688         int error;
 689
 690         if (!handle->cur)
 691                 return -EINVAL;
 692         offset = handle->cur->entries[handle->k];
 693         if (!offset)
 694                 return -EFAULT;
 695         error = bio_read_page(offset, buf);
 696         if (error)
 697                 return error;
 698         if (++handle->k >= MAP_PAGE_ENTRIES) {
 699                 handle->k = 0;
 700                 offset = handle->cur->next_swap;
 701                 if (!offset)
 702                         release_swap_reader(handle);
 703                 else
 704                         error = bio_read_page(offset, handle->cur);
 705         }
 706         return error;
 707 }
 708
 709 /**
 710  *      load_image - load the image using the swap map handle
 711  *      @handle and the snapshot handle @snapshot
 712  *      (assume there are @nr_pages pages to load)
 713  */
 714
 715 static int load_image(struct swap_map_handle *handle,
 716                       struct snapshot_handle *snapshot,
 717                       unsigned int nr_pages)
 718 {
 719         unsigned int m;
 720         int ret;
 721         int error = 0;
 722
 723         printk("Loading image data pages (%u pages) ...     ", nr_pages);
 724         m = nr_pages / 100;
 725         if (!m)
 726                 m = 1;
 727         nr_pages = 0;
 728         do {
 729                 ret = snapshot_write_next(snapshot, PAGE_SIZE);
 730                 if (ret > 0) {
 731                         error = swap_read_page(handle, data_of(*snapshot));
 732                         if (error)
 733                                 break;
 734                         if (!(nr_pages % m))
 735                                 printk("\b\b\b\b%3d%%", nr_pages / m);
 736                         nr_pages++;
 737                 }
 738         } while (ret > 0);
 739         if (!error)
 740                 printk("\b\b\b\bdone\n");
 741         if (!snapshot_image_loaded(snapshot))
 742                 error = -ENODATA;
 743         return error;
 744 }
 745
 746 int swsusp_read(void)
 747 {
 748         int error;
 749         struct swap_map_handle handle;
 750         struct snapshot_handle snapshot;
 751         struct swsusp_info *header;
 752         unsigned int nr_pages;
 753
 754         if (IS_ERR(resume_bdev)) {
 755                 pr_debug("swsusp: block device not initialised\n");
 756                 return PTR_ERR(resume_bdev);
 757         }
 758
 759         memset(&snapshot, 0, sizeof(struct snapshot_handle));
 760         error = snapshot_write_next(&snapshot, PAGE_SIZE);
 761         if (error < PAGE_SIZE)
 762                 return error < 0 ? error : -EFAULT;
 763         header = (struct swsusp_info *)data_of(snapshot);
 764         error = get_swap_reader(&handle, swsusp_header.image);
 765         if (!error)
 766                 error = swap_read_page(&handle, header);
 767         if (!error) {
 768                 nr_pages = header->image_pages;
 769                 error = load_image(&handle, &snapshot, nr_pages);
 770         }
 771         release_swap_reader(&handle);
 772
 773         blkdev_put(resume_bdev);
 774
 775         if (!error)
 776                 pr_debug("swsusp: Reading resume file was successful\n");
 777         else
 778                 pr_debug("swsusp: Error %d resuming\n", error);
 779         return error;
 780 }
 781
 782 /**
 783  *      swsusp_check - Check for swsusp signature in the resume device
 784  */
 785
 786 int swsusp_check(void)
 787 {
 788         int error;
 789
 790         resume_bdev = open_by_devnum(swsusp_resume_device, FMODE_READ);
 791         if (!IS_ERR(resume_bdev)) {
 792                 set_blocksize(resume_bdev, PAGE_SIZE);
 793                 memset(&swsusp_header, 0, sizeof(swsusp_header));
 794                 if ((error = bio_read_page(0, &swsusp_header)))
 795                         return error;
 796                 if (!memcmp(SWSUSP_SIG, swsusp_header.sig, 10)) {
 797                         memcpy(swsusp_header.sig, swsusp_header.orig_sig, 10);
 798                         /* Reset swap signature now */
 799                         error = bio_write_page(0, &swsusp_header);
 800                 } else {
 801                         return -EINVAL;
 802                 }
 803                 if (error)
 804                         blkdev_put(resume_bdev);
 805                 else
 806                         pr_debug("swsusp: Signature found, resuming\n");
 807         } else {
 808                 error = PTR_ERR(resume_bdev);
 809         }
 810
 811         if (error)
 812                 pr_debug("swsusp: Error %d check for resume file\n", error);
 813
 814         return error;
 815 }
 816
 817 /**
 818  *      swsusp_close - close swap device.
 819  */
 820
 821 void swsusp_close(void)
 822 {
 823         if (IS_ERR(resume_bdev)) {
 824                 pr_debug("swsusp: block device not initialised\n");
 825                 return;
 826         }
 827
 828         blkdev_put(resume_bdev);
 829 }