Commit 4034247a authored by NeilBrown's avatar NeilBrown Committed by Linus Torvalds
Browse files

mm: introduce memalloc_retry_wait() 

Various places in the kernel - largely in filesystems - respond to a
memory allocation failure by looping around and re-trying.  Some of
these cannot conveniently use __GFP_NOFAIL, for reasons such as:

 - a GFP_ATOMIC allocation, which __GFP_NOFAIL doesn't work on
 - a need to check for the process being signalled between failures
 - the possibility that other recovery actions could be performed
 - the allocation is quite deep in support code, and passing down an
   extra flag to say if __GFP_NOFAIL is wanted would be clumsy.

Many of these currently use congestion_wait() which (in almost all
cases) simply waits the given timeout - congestion isn't tracked for
most devices.

It isn't clear what the best delay is for loops, but it is clear that
the various filesystems shouldn't be responsible for choosing a timeout.

This patch introduces memalloc_retry_wait() with takes on that
responsibility.  Code that wants to retry a memory allocation can call
this function passing the GFP flags that were used.  It will wait
however is appropriate.

For now, it only considers __GFP_NORETRY and whatever
gfpflags_allow_blocking() tests.  If blocking is allowed without
__GFP_NORETRY, then alloc_page either made some reclaim progress, or
waited for a while, before failing.  So there is no need for much
further waiting.  memalloc_retry_wait() will wait until the current
jiffie ends.  If this condition is not met, then alloc_page() won't have
waited much if at all.  In that case memalloc_retry_wait() waits about
200ms.  This is the delay that most current loops uses.

linux/sched/mm.h needs to be included in some files now,
but linux/backing-dev.h does not.

Link: https://lkml.kernel.org/r/163754371968.13692.1277530886009912421@noble.neil.brown.name


Signed-off-by: default avatarNeilBrown <neilb@suse.de>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Michal Hocko <mhocko@suse.com>
Cc: "Theodore Ts'o" <tytso@mit.edu>
Cc: Jaegeuk Kim <jaegeuk@kernel.org>
Cc: Chao Yu <chao@kernel.org>
Cc: Darrick J. Wong <djwong@kernel.org>
Cc: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 704687de

fs/ext4/extents.c

+3 −5
Original line number Diff line number Diff line
@@ -27,8 +27,8 @@ 
#include <linux/slab.h>

#include <linux/uaccess.h>

#include <linux/fiemap.h>

#include <linux/backing-dev.h>

#include <linux/iomap.h>

#include <linux/sched/mm.h>

#include "ext4_jbd2.h"

#include "ext4_extents.h"

#include "xattr.h"
@@ -4407,8 +4407,7 @@ int ext4_ext_truncate(handle_t *handle, struct inode *inode) 
	err = ext4_es_remove_extent(inode, last_block,

				    EXT_MAX_BLOCKS - last_block);

	if (err == -ENOMEM) {

		cond_resched();

		congestion_wait(BLK_RW_ASYNC, HZ/50);

		memalloc_retry_wait(GFP_ATOMIC);

		goto retry;

	}

	if (err)
@@ -4416,8 +4415,7 @@ int ext4_ext_truncate(handle_t *handle, struct inode *inode) 
retry_remove_space:

	err = ext4_ext_remove_space(inode, last_block, EXT_MAX_BLOCKS - 1);

	if (err == -ENOMEM) {

		cond_resched();

		congestion_wait(BLK_RW_ASYNC, HZ/50);

		memalloc_retry_wait(GFP_ATOMIC);

		goto retry_remove_space;

	}

	return err;

fs/ext4/inline.c

+2 −3
Original line number Diff line number Diff line
@@ -7,7 +7,7 @@ 
#include <linux/iomap.h>

#include <linux/fiemap.h>

#include <linux/iversion.h>

#include <linux/backing-dev.h>

#include <linux/sched/mm.h>



#include "ext4_jbd2.h"

#include "ext4.h"
@@ -1929,8 +1929,7 @@ int ext4_inline_data_truncate(struct inode *inode, int *has_inline) 
retry:

			err = ext4_es_remove_extent(inode, 0, EXT_MAX_BLOCKS);

			if (err == -ENOMEM) {

				cond_resched();

				congestion_wait(BLK_RW_ASYNC, HZ/50);

				memalloc_retry_wait(GFP_ATOMIC);

				goto retry;

			}

			if (err)

fs/ext4/page-io.c

+5 −4
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ 
#include <linux/kernel.h>

#include <linux/slab.h>

#include <linux/mm.h>

#include <linux/backing-dev.h>

#include <linux/sched/mm.h>



#include "ext4_jbd2.h"

#include "xattr.h"
@@ -523,12 +523,13 @@ int ext4_bio_write_page(struct ext4_io_submit *io, 
			ret = PTR_ERR(bounce_page);

			if (ret == -ENOMEM &&

			    (io->io_bio || wbc->sync_mode == WB_SYNC_ALL)) {

				gfp_flags = GFP_NOFS;

				gfp_t new_gfp_flags = GFP_NOFS;

				if (io->io_bio)

					ext4_io_submit(io);

				else

					gfp_flags |= __GFP_NOFAIL;

				congestion_wait(BLK_RW_ASYNC, HZ/50);

					new_gfp_flags |= __GFP_NOFAIL;

				memalloc_retry_wait(gfp_flags);

				gfp_flags = new_gfp_flags;

				goto retry_encrypt;

			}

fs/f2fs/data.c

+2 −2
Original line number Diff line number Diff line
@@ -8,9 +8,9 @@ 
#include <linux/fs.h>

#include <linux/f2fs_fs.h>

#include <linux/buffer_head.h>

#include <linux/sched/mm.h>

#include <linux/mpage.h>

#include <linux/writeback.h>

#include <linux/backing-dev.h>

#include <linux/pagevec.h>

#include <linux/blkdev.h>

#include <linux/bio.h>
@@ -2542,7 +2542,7 @@ int f2fs_encrypt_one_page(struct f2fs_io_info *fio) 
		/* flush pending IOs and wait for a while in the ENOMEM case */

		if (PTR_ERR(fio->encrypted_page) == -ENOMEM) {

			f2fs_flush_merged_writes(fio->sbi);

			congestion_wait(BLK_RW_ASYNC, DEFAULT_IO_TIMEOUT);

			memalloc_retry_wait(GFP_NOFS);

			gfp_flags |= __GFP_NOFAIL;

			goto retry_encrypt;

		}

fs/f2fs/gc.c

+2 −3
Original line number Diff line number Diff line
@@ -7,7 +7,6 @@ 
 */

#include <linux/fs.h>

#include <linux/module.h>

#include <linux/backing-dev.h>

#include <linux/init.h>

#include <linux/f2fs_fs.h>

#include <linux/kthread.h>
@@ -15,6 +14,7 @@ 
#include <linux/freezer.h>

#include <linux/sched/signal.h>

#include <linux/random.h>

#include <linux/sched/mm.h>



#include "f2fs.h"

#include "node.h"
@@ -1375,8 +1375,7 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type, 
		if (err) {

			clear_page_private_gcing(page);

			if (err == -ENOMEM) {

				congestion_wait(BLK_RW_ASYNC,

						DEFAULT_IO_TIMEOUT);

				memalloc_retry_wait(GFP_NOFS);

				goto retry;

			}

			if (is_dirty)