mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros

[mirror_ubuntu-bionic-kernel.git] / mm / page_io.c

diff --git a/mm/page_io.c b/mm/page_io.c
index ff74e512f0292987c4d2e2e738aab0c4c6263fc3..cd92e3d67a32201fac72196a050fb6e47017d33d 100644 (file)
--- a/mm/page_io.c
+++ b/mm/page_io.c
@@ -66,6 +66,54 @@ void end_swap_bio_write(struct bio *bio)
        bio_put(bio);
 }
 
+static void swap_slot_free_notify(struct page *page)
+{
+       struct swap_info_struct *sis;
+       struct gendisk *disk;
+
+       /*
+        * There is no guarantee that the page is in swap cache - the software
+        * suspend code (at least) uses end_swap_bio_read() against a non-
+        * swapcache page.  So we must check PG_swapcache before proceeding with
+        * this optimization.
+        */
+       if (unlikely(!PageSwapCache(page)))
+               return;
+
+       sis = page_swap_info(page);
+       if (!(sis->flags & SWP_BLKDEV))
+               return;
+
+       /*
+        * The swap subsystem performs lazy swap slot freeing,
+        * expecting that the page will be swapped out again.
+        * So we can avoid an unnecessary write if the page
+        * isn't redirtied.
+        * This is good for real swap storage because we can
+        * reduce unnecessary I/O and enhance wear-leveling
+        * if an SSD is used as the as swap device.
+        * But if in-memory swap device (eg zram) is used,
+        * this causes a duplicated copy between uncompressed
+        * data in VM-owned memory and compressed data in
+        * zram-owned memory.  So let's free zram-owned memory
+        * and make the VM-owned decompressed page *dirty*,
+        * so the page should be swapped out somewhere again if
+        * we again wish to reclaim it.
+        */
+       disk = sis->bdev->bd_disk;
+       if (disk->fops->swap_slot_free_notify) {
+               swp_entry_t entry;
+               unsigned long offset;
+
+               entry.val = page_private(page);
+               offset = swp_offset(entry);
+
+               SetPageDirty(page);
+               disk->fops->swap_slot_free_notify(sis->bdev,
+                               offset);
+       }
+}
+
 static void end_swap_bio_read(struct bio *bio)
 {
        struct page *page = bio->bi_io_vec[0].bv_page;
@@ -81,49 +129,7 @@ static void end_swap_bio_read(struct bio *bio)
        }
 
        SetPageUptodate(page);
-
-       /*
-        * There is no guarantee that the page is in swap cache - the software
-        * suspend code (at least) uses end_swap_bio_read() against a non-
-        * swapcache page.  So we must check PG_swapcache before proceeding with
-        * this optimization.
-        */
-       if (likely(PageSwapCache(page))) {
-               struct swap_info_struct *sis;
-
-               sis = page_swap_info(page);
-               if (sis->flags & SWP_BLKDEV) {
-                       /*
-                        * The swap subsystem performs lazy swap slot freeing,
-                        * expecting that the page will be swapped out again.
-                        * So we can avoid an unnecessary write if the page
-                        * isn't redirtied.
-                        * This is good for real swap storage because we can
-                        * reduce unnecessary I/O and enhance wear-leveling
-                        * if an SSD is used as the as swap device.
-                        * But if in-memory swap device (eg zram) is used,
-                        * this causes a duplicated copy between uncompressed
-                        * data in VM-owned memory and compressed data in
-                        * zram-owned memory.  So let's free zram-owned memory
-                        * and make the VM-owned decompressed page *dirty*,
-                        * so the page should be swapped out somewhere again if
-                        * we again wish to reclaim it.
-                        */
-                       struct gendisk *disk = sis->bdev->bd_disk;
-                       if (disk->fops->swap_slot_free_notify) {
-                               swp_entry_t entry;
-                               unsigned long offset;
-
-                               entry.val = page_private(page);
-                               offset = swp_offset(entry);
-
-                               SetPageDirty(page);
-                               disk->fops->swap_slot_free_notify(sis->bdev,
-                                               offset);
-                       }
-               }
-       }
-
+       swap_slot_free_notify(page);
 out:
        unlock_page(page);
        bio_put(bio);
@@ -246,7 +252,7 @@ out:
 
 static sector_t swap_page_sector(struct page *page)
 {
-       return (sector_t)__page_file_index(page) << (PAGE_CACHE_SHIFT - 9);
+       return (sector_t)__page_file_index(page) << (PAGE_SHIFT - 9);
 }
 
 int __swap_writepage(struct page *page, struct writeback_control *wbc,
@@ -347,6 +353,7 @@ int swap_readpage(struct page *page)
 
        ret = bdev_read_page(sis->bdev, swap_page_sector(page), page);
        if (!ret) {
+               swap_slot_free_notify(page);
                count_vm_event(PSWPIN);
                return 0;
        }