ARM: dts: am335x-baltos-ir5221: fix cpsw_emac0 link type

[deliverable/linux.git] / mm / page_io.c

diff --git a/mm/page_io.c b/mm/page_io.c
index b995a5ba5e8f13f49c049e99eface364148d5660..18aac7819cc97b4f2b9fe834600a30614d3e8b33 100644 (file)
--- a/mm/page_io.c
+++ b/mm/page_io.c
@@ -56,31 +56,20 @@ void end_swap_bio_write(struct bio *bio)
                 * Also clear PG_reclaim to avoid rotate_reclaimable_page()
                 */
                set_page_dirty(page);
-               printk(KERN_ALERT "Write-error on swap-device (%u:%u:%Lu)\n",
-                               imajor(bio->bi_bdev->bd_inode),
-                               iminor(bio->bi_bdev->bd_inode),
-                               (unsigned long long)bio->bi_iter.bi_sector);
+               pr_alert("Write-error on swap-device (%u:%u:%llu)\n",
+                        imajor(bio->bi_bdev->bd_inode),
+                        iminor(bio->bi_bdev->bd_inode),
+                        (unsigned long long)bio->bi_iter.bi_sector);
                ClearPageReclaim(page);
        }
        end_page_writeback(page);
        bio_put(bio);
 }
 
-static void end_swap_bio_read(struct bio *bio)
+static void swap_slot_free_notify(struct page *page)
 {
-       struct page *page = bio->bi_io_vec[0].bv_page;
-
-       if (bio->bi_error) {
-               SetPageError(page);
-               ClearPageUptodate(page);
-               printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n",
-                               imajor(bio->bi_bdev->bd_inode),
-                               iminor(bio->bi_bdev->bd_inode),
-                               (unsigned long long)bio->bi_iter.bi_sector);
-               goto out;
-       }
-
-       SetPageUptodate(page);
+       struct swap_info_struct *sis;
+       struct gendisk *disk;
 
        /*
         * There is no guarantee that the page is in swap cache - the software
@@ -88,42 +77,59 @@ static void end_swap_bio_read(struct bio *bio)
         * swapcache page.  So we must check PG_swapcache before proceeding with
         * this optimization.
         */
-       if (likely(PageSwapCache(page))) {
-               struct swap_info_struct *sis;
+       if (unlikely(!PageSwapCache(page)))
+               return;
 
-               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;
+       sis = page_swap_info(page);
+       if (!(sis->flags & SWP_BLKDEV))
+               return;
 
-                               entry.val = page_private(page);
-                               offset = swp_offset(entry);
+       /*
+        * 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;
 
-                               SetPageDirty(page);
-                               disk->fops->swap_slot_free_notify(sis->bdev,
-                                               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;
+
+       if (bio->bi_error) {
+               SetPageError(page);
+               ClearPageUptodate(page);
+               pr_alert("Read-error on swap-device (%u:%u:%llu)\n",
+                        imajor(bio->bi_bdev->bd_inode),
+                        iminor(bio->bi_bdev->bd_inode),
+                        (unsigned long long)bio->bi_iter.bi_sector);
+               goto out;
        }
 
+       SetPageUptodate(page);
+       swap_slot_free_notify(page);
 out:
        unlock_page(page);
        bio_put(bio);
@@ -216,7 +222,7 @@ reprobe:
 out:
        return ret;
 bad_bmap:
-       printk(KERN_ERR "swapon: swapfile has holes\n");
+       pr_err("swapon: swapfile has holes\n");
        ret = -EINVAL;
        goto out;
 }
@@ -290,8 +296,8 @@ int __swap_writepage(struct page *page, struct writeback_control *wbc,
                         */
                        set_page_dirty(page);
                        ClearPageReclaim(page);
-                       pr_err_ratelimited("Write error on dio swapfile (%Lu)\n",
-                               page_file_offset(page));
+                       pr_err_ratelimited("Write error on dio swapfile (%llu)\n",
+                                          page_file_offset(page));
                }
                end_page_writeback(page);
                return ret;
@@ -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;
        }