[PATCH] ext4: Avoid ENOSPC when avoiding to reuse recently deleted inodes

[PATCH] ext4: Avoid ENOSPC when avoiding to reuse recently deleted inodes

[Jan Kara]

When ext4 is running on a filesystem without a journal, it tries not to
reuse recently deleted inodes to provide better chances for filesystem
recovery in case of crash. However this logic forbids reuse of freed
inodes for up to 5 minutes and especially for filesystems with smaller
number of inodes can lead to ENOSPC errors returned when allocating new
inodes.

Fix the problem by allowing to reuse recently deleted inode if there's
no other inode free in the scanned range.

Signed-off-by: Jan Kara <jack@suse.cz>
---
 fs/ext4/ialloc.c | 23 ++++++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

This patch is ramping down the enforcement of recently_deleted() logic rather
significantly. I believe it is fine since IMO it is better to reuse deleted
inode than to disrupt allocation patterns but there's also another option to
disable the recently_deleted() logic only if there's no free inode found in the
whole fs. I can switch to that if people think that it is OK for
recently_deleted() logic to push inode allocations to different group or so.

diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index f95ee99091e4..74f0fe145370 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -712,21 +712,34 @@ static int recently_deleted(struct super_block *sb, ext4_group_t group, int ino)
 static int find_inode_bit(struct super_block *sb, ext4_group_t group,
 			  struct buffer_head *bitmap, unsigned long *ino)
 {
+	bool check_recently_deleted = EXT4_SB(sb)->s_journal == NULL;
+	unsigned long recently_deleted_ino = EXT4_INODES_PER_GROUP(sb);
+
 next:
 	*ino = ext4_find_next_zero_bit((unsigned long *)
 				       bitmap->b_data,
 				       EXT4_INODES_PER_GROUP(sb), *ino);
 	if (*ino >= EXT4_INODES_PER_GROUP(sb))
-		return 0;
+		goto not_found;
 
-	if ((EXT4_SB(sb)->s_journal == NULL) &&
-	    recently_deleted(sb, group, *ino)) {
+	if (check_recently_deleted && recently_deleted(sb, group, *ino)) {
+		recently_deleted_ino = *ino;
 		*ino = *ino + 1;
 		if (*ino < EXT4_INODES_PER_GROUP(sb))
 			goto next;
-		return 0;
+		goto not_found;
 	}
-
+	return 1;
+not_found:
+	if (recently_deleted_ino >= EXT4_INODES_PER_GROUP(sb))
+		return 0;
+	/*
+	 * Not reusing recently deleted inodes is mostly a preference. We don't
+ 	 * want to report ENOSPC or skew allocation patterns because of that.
+	 * So return even recently deleted inode if we could find better in the
+	 * given range.
+	 */
+	*ino = recently_deleted_ino;
 	return 1;
 }
 
-- 
2.16.4

Re: [PATCH] ext4: avoid ENOSPC when avoiding to reuse recently deleted inodes

[Theodore Y. Ts'o]

On Wed, Mar 18, 2020 at 01:13:17PM +0100, Jan Kara wrote:
> When ext4 is running on a filesystem without a journal, it tries not to
> reuse recently deleted inodes to provide better chances for filesystem
> recovery in case of crash. However this logic forbids reuse of freed
> inodes for up to 5 minutes and especially for filesystems with smaller
> number of inodes can lead to ENOSPC errors returned when allocating new
> inodes.
> 
> Fix the problem by allowing to reuse recently deleted inode if there's
> no other inode free in the scanned range.
> 
> Signed-off-by: Jan Kara <jack@suse.cz>

Thanks, applied with a minor whitespace fixup.

		       	     		- Ted