kernel/power/swap.c

   1 /*
   2  * linux/kernel/power/swap.c
   3  *
   4  * This file provides functions for reading the suspend image from
   5  * and writing it to a swap partition.
   6  *
   7  * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@ucw.cz>
   8  * Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
   9  *
  10  * This file is released under the GPLv2.
  11  *
  12  */
  13
  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>
  25 #include <linux/pm.h>
  26 #include <linux/slab.h>
  27
  28 #include "power.h"
  29
  30 #define SWSUSP_SIG      "S1SUSPEND"
  31
  32 /*
  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_ENTRIES swap entries.
  36  *      These structures are stored on the swap and linked together with the
  37  *      help of the .next_swap member.
  38  *
  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.
  42  *
  43  *      During resume we also only need to use one swap_map_page structure
  44  *      at a time.
  45  */
  46
  47 #define MAP_PAGE_ENTRIES        (PAGE_SIZE / sizeof(sector_t) - 1)
  48
  49 struct swap_map_page {
  50         sector_t entries[MAP_PAGE_ENTRIES];
  51         sector_t next_swap;
  52 };
  53
  54 /**
  55  *      The swap_map_handle structure is used for handling swap in
  56  *      a file-alike way
  57  */
  58
  59 struct swap_map_handle {
  60         struct swap_map_page *cur;
  61         sector_t cur_swap;
  62         sector_t first_sector;
  63         unsigned int k;
  64 };
  65
  66 struct swsusp_header {
  67         char reserved[PAGE_SIZE - 20 - sizeof(sector_t) - sizeof(int)];
  68         sector_t image;
  69         unsigned int flags;     /* Flags to pass to the "boot" kernel */
  70         char    orig_sig[10];
  71         char    sig[10];
  72 } __attribute__((packed));
  73
  74 static struct swsusp_header *swsusp_header;
  75
  76 /**
  77  *      The following functions are used for tracing the allocated
  78  *      swap pages, so that they can be freed in case of an error.
  79  */
  80
  81 struct swsusp_extent {
  82         struct rb_node node;
  83         unsigned long start;
  84         unsigned long end;
  85 };
  86
  87 static struct rb_root swsusp_extents = RB_ROOT;
  88
  89 static int swsusp_extents_insert(unsigned long swap_offset)
  90 {
  91         struct rb_node **new = &(swsusp_extents.rb_node);
  92         struct rb_node *parent = NULL;
  93         struct swsusp_extent *ext;
  94
  95         /* Figure out where to put the new node */
  96         while (*new) {
  97                 ext = container_of(*new, struct swsusp_extent, node);
  98                 parent = *new;
  99                 if (swap_offset < ext->start) {
 100                         /* Try to merge */
 101                         if (swap_offset == ext->start - 1) {
 102                                 ext->start--;
 103                                 return 0;
 104                         }
 105                         new = &((*new)->rb_left);
 106                 } else if (swap_offset > ext->end) {
 107                         /* Try to merge */
 108                         if (swap_offset == ext->end + 1) {
 109                                 ext->end++;
 110                                 return 0;
 111                         }
 112                         new = &((*new)->rb_right);
 113                 } else {
 114                         /* It already is in the tree */
 115                         return -EINVAL;
 116                 }
 117         }
 118         /* Add the new node and rebalance the tree. */
 119         ext = kzalloc(sizeof(struct swsusp_extent), GFP_KERNEL);
 120         if (!ext)
 121                 return -ENOMEM;
 122
 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);
 127         return 0;
 128 }
 129
 130 /**
 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.
 133  */
 134
 135 sector_t alloc_swapdev_block(int swap)
 136 {
 137         unsigned long offset;
 138
 139         offset = swp_offset(get_swap_page_of_type(swap));
 140         if (offset) {
 141                 if (swsusp_extents_insert(offset))
 142                         swap_free(swp_entry(swap, offset));
 143                 else
 144                         return swapdev_block(swap, offset);
 145         }
 146         return 0;
 147 }
 148
 149 /**
 150  *      free_all_swap_pages - free swap pages allocated for saving image data.
 151  *      It also frees the extents used to register which swap entries had been
 152  *      allocated.
 153  */
 154
 155 void free_all_swap_pages(int swap)
 156 {
 157         struct rb_node *node;
 158
 159         while ((node = swsusp_extents.rb_node)) {
 160                 struct swsusp_extent *ext;
 161                 unsigned long offset;
 162
 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));
 167
 168                 kfree(ext);
 169         }
 170 }
 171
 172 int swsusp_swap_in_use(void)
 173 {
 174         return (swsusp_extents.rb_node != NULL);
 175 }
 176
 177 /*
 178  * General things
 179  */
 180
 181 static unsigned short root_swap = 0xffff;
 182 struct block_device *hib_resume_bdev;
 183
 184 /*
 185  * Saving part
 186  */
 187
 188 static int mark_swapfiles(struct swap_map_handle *handle, unsigned int flags)
 189 {
 190         int error;
 191
 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);
 201         } else {
 202                 printk(KERN_ERR "PM: Swap header not found!\n");
 203                 error = -ENODEV;
 204         }
 205         return error;
 206 }
 207
 208 /**
 209  *      swsusp_swap_check - check if the resume device is a swap device
 210  *      and get its index (if so)
 211  *
 212  *      This is called before saving image
 213  */
 214 static int swsusp_swap_check(void)
 215 {
 216         int res;
 217
 218         res = swap_type_of(swsusp_resume_device, swsusp_resume_block,
 219                         &hib_resume_bdev);
 220         if (res < 0)
 221                 return res;
 222
 223         root_swap = res;
 224         res = blkdev_get(hib_resume_bdev, FMODE_WRITE);
 225         if (res)
 226                 return res;
 227
 228         res = set_blocksize(hib_resume_bdev, PAGE_SIZE);
 229         if (res < 0)
 230                 blkdev_put(hib_resume_bdev, FMODE_WRITE);
 231
 232         return res;
 233 }
 234
 235 /**
 236  *      write_page - Write one page to given swap location.
 237  *      @buf:           Address we're writing.
 238  *      @offset:        Offset of the swap page we're writing to.
 239  *      @bio_chain:     Link the next write BIO here
 240  */
 241
 242 static int write_page(void *buf, sector_t offset, struct bio **bio_chain)
 243 {
 244         void *src;
 245
 246         if (!offset)
 247                 return -ENOSPC;
 248
 249         if (bio_chain) {
 250                 src = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
 251                 if (src) {
 252                         memcpy(src, buf, PAGE_SIZE);
 253                 } else {
 254                         WARN_ON_ONCE(1);
 255                         bio_chain = NULL;       /* Go synchronous */
 256                         src = buf;
 257                 }
 258         } else {
 259                 src = buf;
 260         }
 261         return hib_bio_write_page(offset, src, bio_chain);
 262 }
 263
 264 static void release_swap_writer(struct swap_map_handle *handle)
 265 {
 266         if (handle->cur)
 267                 free_page((unsigned long)handle->cur);
 268         handle->cur = NULL;
 269 }
 270
 271 static int get_swap_writer(struct swap_map_handle *handle)
 272 {
 273         int ret;
 274
 275         ret = swsusp_swap_check();
 276         if (ret) {
 277                 if (ret != -ENOSPC)
 278                         printk(KERN_ERR "PM: Cannot find swap device, try "
 279                                         "swapon -a.\n");
 280                 return ret;
 281         }
 282         handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
 283         if (!handle->cur) {
 284                 ret = -ENOMEM;
 285                 goto err_close;
 286         }
 287         handle->cur_swap = alloc_swapdev_block(root_swap);
 288         if (!handle->cur_swap) {
 289                 ret = -ENOSPC;
 290                 goto err_rel;
 291         }
 292         handle->k = 0;
 293         handle->first_sector = handle->cur_swap;
 294         return 0;
 295 err_rel:
 296         release_swap_writer(handle);
 297 err_close:
 298         swsusp_close(FMODE_WRITE);
 299         return ret;
 300 }
 301
 302 static int swap_write_page(struct swap_map_handle *handle, void *buf,
 303                                 struct bio **bio_chain)
 304 {
 305         int error = 0;
 306         sector_t offset;
 307
 308         if (!handle->cur)
 309                 return -EINVAL;
 310         offset = alloc_swapdev_block(root_swap);
 311         error = write_page(buf, offset, bio_chain);
 312         if (error)
 313                 return error;
 314         handle->cur->entries[handle->k++] = offset;
 315         if (handle->k >= MAP_PAGE_ENTRIES) {
 316                 error = hib_wait_on_bio_chain(bio_chain);
 317                 if (error)
 318                         goto out;
 319                 offset = alloc_swapdev_block(root_swap);
 320                 if (!offset)
 321                         return -ENOSPC;
 322                 handle->cur->next_swap = offset;
 323                 error = write_page(handle->cur, handle->cur_swap, NULL);
 324                 if (error)
 325                         goto out;
 326                 memset(handle->cur, 0, PAGE_SIZE);
 327                 handle->cur_swap = offset;
 328                 handle->k = 0;
 329         }
 330  out:
 331         return error;
 332 }
 333
 334 static int flush_swap_writer(struct swap_map_handle *handle)
 335 {
 336         if (handle->cur && handle->cur_swap)
 337                 return write_page(handle->cur, handle->cur_swap, NULL);
 338         else
 339                 return -EINVAL;
 340 }
 341
 342 static int swap_writer_finish(struct swap_map_handle *handle,
 343                 unsigned int flags, int error)
 344 {
 345         if (!error) {
 346                 flush_swap_writer(handle);
 347                 printk(KERN_INFO "PM: S");
 348                 error = mark_swapfiles(handle, flags);
 349                 printk("|\n");
 350         }
 351
 352         if (error)
 353                 free_all_swap_pages(root_swap);
 354         release_swap_writer(handle);
 355         swsusp_close(FMODE_WRITE);
 356
 357         return error;
 358 }
 359
 360 /**
 361  *      save_image - save the suspend image data
 362  */
 363
 364 static int save_image(struct swap_map_handle *handle,
 365                       struct snapshot_handle *snapshot,
 366                       unsigned int nr_to_write)
 367 {
 368         unsigned int m;
 369         int ret;
 370         int nr_pages;
 371         int err2;
 372         struct bio *bio;
 373         struct timeval start;
 374         struct timeval stop;
 375
 376         printk(KERN_INFO "PM: Saving image data pages (%u pages) ...     ",
 377                 nr_to_write);
 378         m = nr_to_write / 100;
 379         if (!m)
 380                 m = 1;
 381         nr_pages = 0;
 382         bio = NULL;
 383         do_gettimeofday(&start);
 384         while (1) {
 385                 ret = snapshot_read_next(snapshot);
 386                 if (ret <= 0)
 387                         break;
 388                 ret = swap_write_page(handle, data_of(*snapshot), &bio);
 389                 if (ret)
 390                         break;
 391                 if (!(nr_pages % m))
 392                         printk(KERN_CONT "\b\b\b\b%3d%%", nr_pages / m);
 393                 nr_pages++;
 394         }
 395         err2 = hib_wait_on_bio_chain(&bio);
 396         do_gettimeofday(&stop);
 397         if (!ret)
 398                 ret = err2;
 399         if (!ret)
 400                 printk(KERN_CONT "\b\b\b\bdone\n");
 401         else
 402                 printk(KERN_CONT "\n");
 403         swsusp_show_speed(&start, &stop, nr_to_write, "Wrote");
 404         return ret;
 405 }
 406
 407 /**
 408  *      enough_swap - Make sure we have enough swap to save the image.
 409  *
 410  *      Returns TRUE or FALSE after checking the total amount of swap
 411  *      space avaiable from the resume partition.
 412  */
 413
 414 static int enough_swap(unsigned int nr_pages)
 415 {
 416         unsigned int free_swap = count_swap_pages(root_swap, 1);
 417
 418         pr_debug("PM: Free swap pages: %u\n", free_swap);
 419         return free_swap > nr_pages + PAGES_FOR_IO;
 420 }
 421
 422 /**
 423  *      swsusp_write - Write entire image and metadata.
 424  *      @flags: flags to pass to the "boot" kernel in the image header
 425  *
 426  *      It is important _NOT_ to umount filesystems at this point. We want
 427  *      them synced (in case something goes wrong) but we DO not want to mark
 428  *      filesystem clean: it is not. (And it does not matter, if we resume
 429  *      correctly, we'll mark system clean, anyway.)
 430  */
 431
 432 int swsusp_write(unsigned int flags)
 433 {
 434         struct swap_map_handle handle;
 435         struct snapshot_handle snapshot;
 436         struct swsusp_info *header;
 437         unsigned long pages;
 438         int error;
 439
 440         pages = snapshot_get_image_size();
 441         error = get_swap_writer(&handle);
 442         if (error) {
 443                 printk(KERN_ERR "PM: Cannot get swap writer\n");
 444                 return error;
 445         }
 446         if (!enough_swap(pages)) {
 447                 printk(KERN_ERR "PM: Not enough free swap\n");
 448                 error = -ENOSPC;
 449                 goto out_finish;
 450         }
 451         memset(&snapshot, 0, sizeof(struct snapshot_handle));
 452         error = snapshot_read_next(&snapshot);
 453         if (error < PAGE_SIZE) {
 454                 if (error >= 0)
 455                         error = -EFAULT;
 456
 457                 goto out_finish;
 458         }
 459         header = (struct swsusp_info *)data_of(snapshot);
 460         error = swap_write_page(&handle, header, NULL);
 461         if (!error)
 462                 error = save_image(&handle, &snapshot, pages - 1);
 463 out_finish:
 464         error = swap_writer_finish(&handle, flags, error);
 465         return error;
 466 }
 467
 468 /**
 469  *      The following functions allow us to read data using a swap map
 470  *      in a file-alike way
 471  */
 472
 473 static void release_swap_reader(struct swap_map_handle *handle)
 474 {
 475         if (handle->cur)
 476                 free_page((unsigned long)handle->cur);
 477         handle->cur = NULL;
 478 }
 479
 480 static int get_swap_reader(struct swap_map_handle *handle,
 481                 unsigned int *flags_p)
 482 {
 483         int error;
 484
 485         *flags_p = swsusp_header->flags;
 486
 487         if (!swsusp_header->image) /* how can this happen? */
 488                 return -EINVAL;
 489
 490         handle->cur = (struct swap_map_page *)get_zeroed_page(__GFP_WAIT | __GFP_HIGH);
 491         if (!handle->cur)
 492                 return -ENOMEM;
 493
 494         error = hib_bio_read_page(swsusp_header->image, handle->cur, NULL);
 495         if (error) {
 496                 release_swap_reader(handle);
 497                 return error;
 498         }
 499         handle->k = 0;
 500         return 0;
 501 }
 502
 503 static int swap_read_page(struct swap_map_handle *handle, void *buf,
 504                                 struct bio **bio_chain)
 505 {
 506         sector_t offset;
 507         int error;
 508
 509         if (!handle->cur)
 510                 return -EINVAL;
 511         offset = handle->cur->entries[handle->k];
 512         if (!offset)
 513                 return -EFAULT;
 514         error = hib_bio_read_page(offset, buf, bio_chain);
 515         if (error)
 516                 return error;
 517         if (++handle->k >= MAP_PAGE_ENTRIES) {
 518                 error = hib_wait_on_bio_chain(bio_chain);
 519                 handle->k = 0;
 520                 offset = handle->cur->next_swap;
 521                 if (!offset)
 522                         release_swap_reader(handle);
 523                 else if (!error)
 524                         error = hib_bio_read_page(offset, handle->cur, NULL);
 525         }
 526         return error;
 527 }
 528
 529 static int swap_reader_finish(struct swap_map_handle *handle)
 530 {
 531         release_swap_reader(handle);
 532
 533         return 0;
 534 }
 535
 536 /**
 537  *      load_image - load the image using the swap map handle
 538  *      @handle and the snapshot handle @snapshot
 539  *      (assume there are @nr_pages pages to load)
 540  */
 541
 542 static int load_image(struct swap_map_handle *handle,
 543                       struct snapshot_handle *snapshot,
 544                       unsigned int nr_to_read)
 545 {
 546         unsigned int m;
 547         int error = 0;
 548         struct timeval start;
 549         struct timeval stop;
 550         struct bio *bio;
 551         int err2;
 552         unsigned nr_pages;
 553
 554         printk(KERN_INFO "PM: Loading image data pages (%u pages) ...     ",
 555                 nr_to_read);
 556         m = nr_to_read / 100;
 557         if (!m)
 558                 m = 1;
 559         nr_pages = 0;
 560         bio = NULL;
 561         do_gettimeofday(&start);
 562         for ( ; ; ) {
 563                 error = snapshot_write_next(snapshot);
 564                 if (error <= 0)
 565                         break;
 566                 error = swap_read_page(handle, data_of(*snapshot), &bio);
 567                 if (error)
 568                         break;
 569                 if (snapshot->sync_read)
 570                         error = hib_wait_on_bio_chain(&bio);
 571                 if (error)
 572                         break;
 573                 if (!(nr_pages % m))
 574                         printk("\b\b\b\b%3d%%", nr_pages / m);
 575                 nr_pages++;
 576         }
 577         err2 = hib_wait_on_bio_chain(&bio);
 578         do_gettimeofday(&stop);
 579         if (!error)
 580                 error = err2;
 581         if (!error) {
 582                 printk("\b\b\b\bdone\n");
 583                 snapshot_write_finalize(snapshot);
 584                 if (!snapshot_image_loaded(snapshot))
 585                         error = -ENODATA;
 586         } else
 587                 printk("\n");
 588         swsusp_show_speed(&start, &stop, nr_to_read, "Read");
 589         return error;
 590 }
 591
 592 /**
 593  *      swsusp_read - read the hibernation image.
 594  *      @flags_p: flags passed by the "frozen" kernel in the image header should
 595  *                be written into this memeory location
 596  */
 597
 598 int swsusp_read(unsigned int *flags_p)
 599 {
 600         int error;
 601         struct swap_map_handle handle;
 602         struct snapshot_handle snapshot;
 603         struct swsusp_info *header;
 604
 605         memset(&snapshot, 0, sizeof(struct snapshot_handle));
 606         error = snapshot_write_next(&snapshot);
 607         if (error < PAGE_SIZE)
 608                 return error < 0 ? error : -EFAULT;
 609         header = (struct swsusp_info *)data_of(snapshot);
 610         error = get_swap_reader(&handle, flags_p);
 611         if (error)
 612                 goto end;
 613         if (!error)
 614                 error = swap_read_page(&handle, header, NULL);
 615         if (!error)
 616                 error = load_image(&handle, &snapshot, header->pages - 1);
 617         swap_reader_finish(&handle);
 618 end:
 619         if (!error)
 620                 pr_debug("PM: Image successfully loaded\n");
 621         else
 622                 pr_debug("PM: Error %d resuming\n", error);
 623         return error;
 624 }
 625
 626 /**
 627  *      swsusp_check - Check for swsusp signature in the resume device
 628  */
 629
 630 int swsusp_check(void)
 631 {
 632         int error;
 633
 634         hib_resume_bdev = open_by_devnum(swsusp_resume_device, FMODE_READ);
 635         if (!IS_ERR(hib_resume_bdev)) {
 636                 set_blocksize(hib_resume_bdev, PAGE_SIZE);
 637                 memset(swsusp_header, 0, PAGE_SIZE);
 638                 error = hib_bio_read_page(swsusp_resume_block,
 639                                         swsusp_header, NULL);
 640                 if (error)
 641                         goto put;
 642
 643                 if (!memcmp(SWSUSP_SIG, swsusp_header->sig, 10)) {
 644                         memcpy(swsusp_header->sig, swsusp_header->orig_sig, 10);
 645                         /* Reset swap signature now */
 646                         error = hib_bio_write_page(swsusp_resume_block,
 647                                                 swsusp_header, NULL);
 648                 } else {
 649                         error = -EINVAL;
 650                 }
 651
 652 put:
 653                 if (error)
 654                         blkdev_put(hib_resume_bdev, FMODE_READ);
 655                 else
 656                         pr_debug("PM: Signature found, resuming\n");
 657         } else {
 658                 error = PTR_ERR(hib_resume_bdev);
 659         }
 660
 661         if (error)
 662                 pr_debug("PM: Error %d checking image file\n", error);
 663
 664         return error;
 665 }
 666
 667 /**
 668  *      swsusp_close - close swap device.
 669  */
 670
 671 void swsusp_close(fmode_t mode)
 672 {
 673         if (IS_ERR(hib_resume_bdev)) {
 674                 pr_debug("PM: Image device not initialised\n");
 675                 return;
 676         }
 677
 678         blkdev_put(hib_resume_bdev, mode);
 679 }
 680
 681 static int swsusp_header_init(void)
 682 {
 683         swsusp_header = (struct swsusp_header*) __get_free_page(GFP_KERNEL);
 684         if (!swsusp_header)
 685                 panic("Could not allocate memory for swsusp_header\n");
 686         return 0;
 687 }
 688
 689 core_initcall(swsusp_header_init);