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