mm/fs: delete PF_SWAPWRITE

PF_SWAPWRITE has been redundant since v3.2 commit ee72886d8ed5 ("mm:
vmscan: do not writeback filesystem pages in direct reclaim").

Coincidentally, NeilBrown's current patch "remove inode_congested()"
deletes may_write_to_inode(), which appeared to be the one function which
took notice of PF_SWAPWRITE.  But if you study the old logic, and the
conditions under which may_write_to_inode() was called, you discover that
flag and function have been pointless for a decade.

Link: https://lkml.kernel.org/r/75e80e7-742d-e3bd-531-614db8961e4@google.com
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: NeilBrown <neilb@suse.de>
Cc: Jan Kara <jack@suse.de>
Cc: "Darrick J. Wong" <djwong@kernel.org>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Matthew Wilcox <willy@infradead.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index 42a3dfad40b80578f24f0aff501f89666e3955b6..3d8dacfff15073470c9f4fe28d4cf4d277241d7d 100644 (file)
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -2197,7 +2197,6 @@ void wb_workfn(struct work_struct *work)
        long pages_written;
 
        set_worker_desc("flush-%s", bdi_dev_name(wb->bdi));
-       current->flags |= PF_SWAPWRITE;
 
        if (likely(!current_is_workqueue_rescuer() ||
                   !test_bit(WB_registered, &wb->state))) {
@@ -2226,8 +2225,6 @@ void wb_workfn(struct work_struct *work)
                wb_wakeup(wb);
        else if (wb_has_dirty_io(wb) && dirty_writeback_interval)
                wb_wakeup_delayed(wb);
-
-       current->flags &= ~PF_SWAPWRITE;
 }
 
 /*

diff --git a/fs/xfs/libxfs/xfs_btree.c b/fs/xfs/libxfs/xfs_btree.c
index f18a875f51c62ea8123637059eae89a7f5f48f58..c1500b23852056499570a08f3bc6c2b0889cb41d 100644 (file)
--- a/fs/xfs/libxfs/xfs_btree.c
+++ b/fs/xfs/libxfs/xfs_btree.c
@@ -2818,7 +2818,7 @@ xfs_btree_split_worker(
         * in any way.
         */
        if (args->kswapd)
-               new_pflags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD;
+               new_pflags |= PF_MEMALLOC | PF_KSWAPD;
 
        current_set_flags_nested(&pflags, new_pflags);
        xfs_trans_set_context(args->cur->bc_tp);

diff --git a/include/linux/sched.h b/include/linux/sched.h
index 75ba8aa60248b57be7c82090346bb5057e39ef95..c3c841a02a00a74fa0d8fe96d08e1b100e50252c 100644 (file)
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1689,7 +1689,6 @@ extern struct pid *cad_pid;
                                                 * I am cleaning dirty pages from some other bdi. */
 #define PF_KTHREAD             0x00200000      /* I am a kernel thread */
 #define PF_RANDOMIZE           0x00400000      /* Randomize virtual address space */
-#define PF_SWAPWRITE           0x00800000      /* Allowed to write to swap */
 #define PF_NO_SETAFFINITY      0x04000000      /* Userland is not allowed to meddle with cpus_mask */
 #define PF_MCE_EARLY           0x08000000      /* Early kill for mce process policy */
 #define PF_MEMALLOC_PIN                0x10000000      /* Allocation context constrained to zones which allow long term pinning. */

diff --git a/mm/migrate.c b/mm/migrate.c
index 4359d49b508a5275b48f8d186ea51054cb18a224..fc75c409482e350182dbc182427990bf9a9833b1 100644 (file)
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -1350,7 +1350,6 @@ int migrate_pages(struct list_head *from, new_page_t get_new_page,
        bool is_thp = false;
        struct page *page;
        struct page *page2;
-       int swapwrite = current->flags & PF_SWAPWRITE;
        int rc, nr_subpages;
        LIST_HEAD(ret_pages);
        LIST_HEAD(thp_split_pages);
@@ -1359,9 +1358,6 @@ int migrate_pages(struct list_head *from, new_page_t get_new_page,
 
        trace_mm_migrate_pages_start(mode, reason);
 
-       if (!swapwrite)
-               current->flags |= PF_SWAPWRITE;
-
 thp_subpage_migration:
        for (pass = 0; pass < 10 && (retry || thp_retry); pass++) {
                retry = 0;
@@ -1516,9 +1512,6 @@ out:
        trace_mm_migrate_pages(nr_succeeded, nr_failed_pages, nr_thp_succeeded,
                               nr_thp_failed, nr_thp_split, mode, reason);
 
-       if (!swapwrite)
-               current->flags &= ~PF_SWAPWRITE;
-
        if (ret_succeeded)
                *ret_succeeded = nr_succeeded;
 

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 5e1469887afa8806aa4bf00b5ac9304fd7d368f7..d4168966311fb7d13a786cb48889022c2aa44058 100644 (file)
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -4457,7 +4457,7 @@ static int kswapd(void *p)
         * us from recursively trying to free more memory as we're
         * trying to free the first piece of memory in the first place).
         */
-       tsk->flags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD;
+       tsk->flags |= PF_MEMALLOC | PF_KSWAPD;
        set_freezable();
 
        WRITE_ONCE(pgdat->kswapd_order, 0);
@@ -4508,7 +4508,7 @@ kswapd_try_sleep:
                        goto kswapd_try_sleep;
        }
 
-       tsk->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD);
+       tsk->flags &= ~(PF_MEMALLOC | PF_KSWAPD);
 
        return 0;
 }
@@ -4749,11 +4749,8 @@ static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned in
        fs_reclaim_acquire(sc.gfp_mask);
        /*
         * We need to be able to allocate from the reserves for RECLAIM_UNMAP
-        * and we also need to be able to write out pages for RECLAIM_WRITE
-        * and RECLAIM_UNMAP.
         */
        noreclaim_flag = memalloc_noreclaim_save();
-       p->flags |= PF_SWAPWRITE;
        set_task_reclaim_state(p, &sc.reclaim_state);
 
        if (node_pagecache_reclaimable(pgdat) > pgdat->min_unmapped_pages) {
@@ -4767,7 +4764,6 @@ static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned in
        }
 
        set_task_reclaim_state(p, NULL);
-       current->flags &= ~PF_SWAPWRITE;
        memalloc_noreclaim_restore(noreclaim_flag);
        fs_reclaim_release(sc.gfp_mask);
        psi_memstall_leave(&pflags);