page_io.c 3.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149
  1. /*
  2. * linux/mm/page_io.c
  3. *
  4. * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
  5. *
  6. * Swap reorganised 29.12.95,
  7. * Asynchronous swapping added 30.12.95. Stephen Tweedie
  8. * Removed race in async swapping. 14.4.1996. Bruno Haible
  9. * Add swap of shared pages through the page cache. 20.2.1998. Stephen Tweedie
  10. * Always use brw_page, life becomes simpler. 12 May 1998 Eric Biederman
  11. */
  12. #include <linux/mm.h>
  13. #include <linux/kernel_stat.h>
  14. #include <linux/pagemap.h>
  15. #include <linux/swap.h>
  16. #include <linux/bio.h>
  17. #include <linux/swapops.h>
  18. #include <linux/writeback.h>
  19. #include <asm/pgtable.h>
  20. static struct bio *get_swap_bio(gfp_t gfp_flags, pgoff_t index,
  21. struct page *page, bio_end_io_t end_io)
  22. {
  23. struct bio *bio;
  24. bio = bio_alloc(gfp_flags, 1);
  25. if (bio) {
  26. struct swap_info_struct *sis;
  27. swp_entry_t entry = { .val = index, };
  28. sis = get_swap_info_struct(swp_type(entry));
  29. bio->bi_sector = map_swap_page(sis, swp_offset(entry)) *
  30. (PAGE_SIZE >> 9);
  31. bio->bi_bdev = sis->bdev;
  32. bio->bi_io_vec[0].bv_page = page;
  33. bio->bi_io_vec[0].bv_len = PAGE_SIZE;
  34. bio->bi_io_vec[0].bv_offset = 0;
  35. bio->bi_vcnt = 1;
  36. bio->bi_idx = 0;
  37. bio->bi_size = PAGE_SIZE;
  38. bio->bi_end_io = end_io;
  39. }
  40. return bio;
  41. }
  42. static int end_swap_bio_write(struct bio *bio, unsigned int bytes_done, int err)
  43. {
  44. const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
  45. struct page *page = bio->bi_io_vec[0].bv_page;
  46. if (bio->bi_size)
  47. return 1;
  48. if (!uptodate) {
  49. SetPageError(page);
  50. /*
  51. * We failed to write the page out to swap-space.
  52. * Re-dirty the page in order to avoid it being reclaimed.
  53. * Also print a dire warning that things will go BAD (tm)
  54. * very quickly.
  55. *
  56. * Also clear PG_reclaim to avoid rotate_reclaimable_page()
  57. */
  58. set_page_dirty(page);
  59. printk(KERN_ALERT "Write-error on swap-device (%u:%u:%Lu)\n",
  60. imajor(bio->bi_bdev->bd_inode),
  61. iminor(bio->bi_bdev->bd_inode),
  62. (unsigned long long)bio->bi_sector);
  63. ClearPageReclaim(page);
  64. }
  65. end_page_writeback(page);
  66. bio_put(bio);
  67. return 0;
  68. }
  69. int end_swap_bio_read(struct bio *bio, unsigned int bytes_done, int err)
  70. {
  71. const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
  72. struct page *page = bio->bi_io_vec[0].bv_page;
  73. if (bio->bi_size)
  74. return 1;
  75. if (!uptodate) {
  76. SetPageError(page);
  77. ClearPageUptodate(page);
  78. printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n",
  79. imajor(bio->bi_bdev->bd_inode),
  80. iminor(bio->bi_bdev->bd_inode),
  81. (unsigned long long)bio->bi_sector);
  82. } else {
  83. SetPageUptodate(page);
  84. }
  85. unlock_page(page);
  86. bio_put(bio);
  87. return 0;
  88. }
  89. /*
  90. * We may have stale swap cache pages in memory: notice
  91. * them here and get rid of the unnecessary final write.
  92. */
  93. int swap_writepage(struct page *page, struct writeback_control *wbc)
  94. {
  95. struct bio *bio;
  96. int ret = 0, rw = WRITE;
  97. if (remove_exclusive_swap_page(page)) {
  98. unlock_page(page);
  99. goto out;
  100. }
  101. bio = get_swap_bio(GFP_NOIO, page_private(page), page,
  102. end_swap_bio_write);
  103. if (bio == NULL) {
  104. set_page_dirty(page);
  105. unlock_page(page);
  106. ret = -ENOMEM;
  107. goto out;
  108. }
  109. if (wbc->sync_mode == WB_SYNC_ALL)
  110. rw |= (1 << BIO_RW_SYNC);
  111. count_vm_event(PSWPOUT);
  112. set_page_writeback(page);
  113. unlock_page(page);
  114. submit_bio(rw, bio);
  115. out:
  116. return ret;
  117. }
  118. int swap_readpage(struct file *file, struct page *page)
  119. {
  120. struct bio *bio;
  121. int ret = 0;
  122. BUG_ON(!PageLocked(page));
  123. ClearPageUptodate(page);
  124. bio = get_swap_bio(GFP_KERNEL, page_private(page), page,
  125. end_swap_bio_read);
  126. if (bio == NULL) {
  127. unlock_page(page);
  128. ret = -ENOMEM;
  129. goto out;
  130. }
  131. count_vm_event(PSWPIN);
  132. submit_bio(READ, bio);
  133. out:
  134. return ret;
  135. }