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