Patch "btrfs: error out when reallocating block for defrag using a stale transaction" has been added to the 6.1-stable tree

[Sasha Levin <sashal@xxxxxxxxxx>]

This is a note to let you know that I've just added the patch titled

    btrfs: error out when reallocating block for defrag using a stale transaction

to the 6.1-stable tree which can be found at:
    http://www.kernel.org/git/?p=linux/kernel/git/stable/stable-queue.git;a=summary

The filename of the patch is:
     btrfs-error-out-when-reallocating-block-for-defrag-u.patch
and it can be found in the queue-6.1 subdirectory.

If you, or anyone else, feels it should not be added to the stable tree,
please let <stable@xxxxxxxxxxxxxxx> know about it.



commit 53306197a65c328a7f50c8a1be33bd4574f840dd
Author: Filipe Manana <fdmanana@xxxxxxxx>
Date:   Wed Sep 27 12:09:23 2023 +0100

    btrfs: error out when reallocating block for defrag using a stale transaction
    
    [ Upstream commit e36f94914021e58ee88a8856c7fdf35adf9c7ee1 ]
    
    At btrfs_realloc_node() we have these checks to verify we are not using a
    stale transaction (a past transaction with an unblocked state or higher),
    and the only thing we do is to trigger two WARN_ON(). This however is a
    critical problem, highly unexpected and if it happens it's most likely due
    to a bug, so we should error out and turn the fs into error state so that
    such issue is much more easily noticed if it's triggered.
    
    The problem is critical because in btrfs_realloc_node() we COW tree blocks,
    and using such stale transaction will lead to not persisting the extent
    buffers used for the COW operations, as allocating tree block adds the
    range of the respective extent buffers to the ->dirty_pages iotree of the
    transaction, and a stale transaction, in the unlocked state or higher,
    will not flush dirty extent buffers anymore, therefore resulting in not
    persisting the tree block and resource leaks (not cleaning the dirty_pages
    iotree for example).
    
    So do the following changes:
    
    1) Return -EUCLEAN if we find a stale transaction;
    
    2) Turn the fs into error state, with error -EUCLEAN, so that no
       transaction can be committed, and generate a stack trace;
    
    3) Combine both conditions into a single if statement, as both are related
       and have the same error message;
    
    4) Mark the check as unlikely, since this is not expected to ever happen.
    
    Signed-off-by: Filipe Manana <fdmanana@xxxxxxxx>
    Reviewed-by: David Sterba <dsterba@xxxxxxxx>
    Signed-off-by: David Sterba <dsterba@xxxxxxxx>
    Signed-off-by: Sasha Levin <sashal@xxxxxxxxxx>

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 98f68bd1383a3..e08688844f1e1 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -698,8 +698,22 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
 	int progress_passed = 0;
 	struct btrfs_disk_key disk_key;
 
-	WARN_ON(trans->transaction != fs_info->running_transaction);
-	WARN_ON(trans->transid != fs_info->generation);
+	/*
+	 * COWing must happen through a running transaction, which always
+	 * matches the current fs generation (it's a transaction with a state
+	 * less than TRANS_STATE_UNBLOCKED). If it doesn't, then turn the fs
+	 * into error state to prevent the commit of any transaction.
+	 */
+	if (unlikely(trans->transaction != fs_info->running_transaction ||
+		     trans->transid != fs_info->generation)) {
+		btrfs_abort_transaction(trans, -EUCLEAN);
+		btrfs_crit(fs_info,
+"unexpected transaction when attempting to reallocate parent %llu for root %llu, transaction %llu running transaction %llu fs generation %llu",
+			   parent->start, btrfs_root_id(root), trans->transid,
+			   fs_info->running_transaction->transid,
+			   fs_info->generation);
+		return -EUCLEAN;
+	}
 
 	parent_nritems = btrfs_header_nritems(parent);
 	blocksize = fs_info->nodesize;