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