diff options
author | Nikolay Borisov <nborisov@suse.com> | 2019-10-15 18:42:24 +0300 |
---|---|---|
committer | David Sterba <dsterba@suse.com> | 2019-11-18 17:51:47 +0100 |
commit | 6ef108dd0cda65d3031166222e64cdf71fdd3359 (patch) | |
tree | 38b0a01cc94b0e1c1ec3471b3ad5e63f38f530ff /fs | |
parent | 4ac039ad75df3f5f5f5b2b7439f094ad5bd9dbbe (diff) | |
download | linux-6ef108dd0cda65d3031166222e64cdf71fdd3359.tar.gz linux-6ef108dd0cda65d3031166222e64cdf71fdd3359.tar.bz2 linux-6ef108dd0cda65d3031166222e64cdf71fdd3359.zip |
btrfs: Streamline btrfs_fs_info::backup_root_index semantics
The backup_root_index member stores the index at which the backup root
should be saved upon next transaction commit. However, there is a
small deviation from this behavior in the form of a check in
backup_super_roots which checks if current root generation equals to the
generation of the previous root. This can trigger in the following
scenario:
slot0: gen-2
slot1: gen-1
slot2: gen
slot3: unused
Now suppose slot3 (which is also the root specified in the super block)
is corrupted hence init_tree_roots chooses to use the backup root at
slot2, meaning read_backup_root will read slot2 and assign the
superblock generation to gen-1. Despite this backup_root_index will
point at slot3 because its init happens in init_backup_root_slot, long
before any parsing of the backup roots occur. Then on next transaction
start, gen-1 will be incremented by 1 making the root's generation
equal gen. Subsequently, on transaction commit the following check
triggers:
if (btrfs_backup_tree_root_gen(root_backup) ==
btrfs_header_generation(info->tree_root->node))
This causes the 'next_backup', which is the index at which the backup is
going to be written to, to set to last_backup, which will be slot2.
All of this is a very confusing way of expressing the following
invariant:
Always write a backup root at the index following the last used backup
root.
This commit streamlines this logic by setting backup_root_index to the
next index after the one used for mount.
Signed-off-by: Nikolay Borisov <nborisov@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
Diffstat (limited to 'fs')
-rw-r--r-- | fs/btrfs/disk-io.c | 51 |
1 files changed, 12 insertions, 39 deletions
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c index 6c44d1781f21..ddb39f76f71a 100644 --- a/fs/btrfs/disk-io.c +++ b/fs/btrfs/disk-io.c @@ -1816,45 +1816,14 @@ static int find_newest_super_backup(struct btrfs_fs_info *info) } /* - * Initialize backup_root_index with the next available slot, where subsequent - * transaction commit will store the backup root - */ -static void init_backup_root_slot(struct btrfs_fs_info *info) -{ - int newest_index; - - newest_index = find_newest_super_backup(info); - /* if there was garbage in there, just move along */ - if (newest_index == -EINVAL) { - info->backup_root_index = 0; - } else { - info->backup_root_index = (newest_index + 1) % BTRFS_NUM_BACKUP_ROOTS; - } -} - -/* * copy all the root pointers into the super backup array. * this will bump the backup pointer by one when it is * done */ static void backup_super_roots(struct btrfs_fs_info *info) { - int next_backup; + const int next_backup = info->backup_root_index; struct btrfs_root_backup *root_backup; - int last_backup; - - next_backup = info->backup_root_index; - last_backup = (next_backup + BTRFS_NUM_BACKUP_ROOTS - 1) % - BTRFS_NUM_BACKUP_ROOTS; - - /* - * just overwrite the last backup if we're at the same generation - * this happens only at umount - */ - root_backup = info->super_for_commit->super_roots + last_backup; - if (btrfs_backup_tree_root_gen(root_backup) == - btrfs_header_generation(info->tree_root->node)) - next_backup = last_backup; root_backup = info->super_for_commit->super_roots + next_backup; @@ -2558,8 +2527,9 @@ out: return ret; } -int __cold init_tree_roots(struct btrfs_fs_info *fs_info) +static int __cold init_tree_roots(struct btrfs_fs_info *fs_info) { + int backup_index = find_newest_super_backup(fs_info); struct btrfs_super_block *sb = fs_info->super_copy; struct btrfs_root *tree_root = fs_info->tree_root; bool handle_error = false; @@ -2590,6 +2560,7 @@ int __cold init_tree_roots(struct btrfs_fs_info *fs_info) btrfs_set_opt(fs_info->mount_opt, CLEAR_CACHE); ret = read_backup_root(fs_info, i); + backup_index = ret; if (ret < 0) return ret; } @@ -2636,6 +2607,14 @@ int __cold init_tree_roots(struct btrfs_fs_info *fs_info) /* All successful */ fs_info->generation = generation; fs_info->last_trans_committed = generation; + + /* Always begin writing backup roots after the one being used */ + if (backup_index < 0) { + fs_info->backup_root_index = 0; + } else { + fs_info->backup_root_index = backup_index + 1; + fs_info->backup_root_index %= BTRFS_NUM_BACKUP_ROOTS; + } break; } @@ -2930,12 +2909,6 @@ int __cold open_ctree(struct super_block *sb, set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state); /* - * run through our array of backup supers and setup - * our ring pointer to the oldest one - */ - init_backup_root_slot(fs_info); - - /* * In the long term, we'll store the compression type in the super * block, and it'll be used for per file compression control. */ |