On 25.12.18 г. 7:28 ч., Qu Wenruo wrote:
> The code is mostly ported from kernel with minimal change.
>
> Since btrfs-progs doesn't support replaying log, there is some code
> unnecessary for btrfs-progs, but to keep the code the same, that
> unnecessary code is kept as it.
>
> Now "btrfs check --repair" will update backup roots correctly.
>
> Signed-off-by: Qu Wenruo <wqu@xxxxxxxx>
> ---
> disk-io.c | 78 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 78 insertions(+)
>
> diff --git a/disk-io.c b/disk-io.c
> index 133835a4d063..f28a6b526391 100644
> --- a/disk-io.c
> +++ b/disk-io.c
> @@ -1621,6 +1621,83 @@ write_err:
> return ret;
> }
>
> +/*
> + * 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)
> +{
> + struct btrfs_root_backup *root_backup;
> + int next_backup;
> + int last_backup;
> +
> + last_backup = find_best_backup_root(info->super_copy);
Slightly offtopic: but find_best_backup_root only partially resembles
it's kernel counterpart - find_newest_super_backup. And it's missing the
code for handling wraparound. So in kernel space if the newest root is
at index 3 and index 0 backup also has the same gen then we switch the
index to 0, why is this needed? In any case I think
'find_best_backup_root' in progs should be renamed to
'find_newest_super_backup' and copied from kernel space.
> + next_backup = (last_backup + 1) % BTRFS_NUM_BACKUP_ROOTS;
This logic is different than the kernel one which does:
last_backup = (next_backup + BTRFS_NUM_BACKUP_ROOTS - 1) %
BTRFS_NUM_BACKUP_ROOTS;
So in the kernel when info->backup_root_index == 0 then the newest
backup root is going to be written at position 3, the next one in pos 1,
the next in pos 2 and so on. OTOH in userspace we might potentially
start writing at 1 (which doesn't seem problematic per se). So why the
difference in logic?
> +
> + /* just overwrite the last backup if we're at the same generation */
> + root_backup = info->super_copy->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_copy->super_roots + next_backup;
> +
> + /*
> + * make sure all of our padding and empty slots get zero filled
> + * regardless of which ones we use today
> + */
> + memset(root_backup, 0, sizeof(*root_backup));
> + btrfs_set_backup_tree_root(root_backup, info->tree_root->node->start);
> + btrfs_set_backup_tree_root_gen(root_backup,
> + btrfs_header_generation(info->tree_root->node));
> + btrfs_set_backup_tree_root_level(root_backup,
> + btrfs_header_level(info->tree_root->node));
> +
> + btrfs_set_backup_chunk_root(root_backup, info->chunk_root->node->start);
> + btrfs_set_backup_chunk_root_gen(root_backup,
> + btrfs_header_generation(info->chunk_root->node));
> + btrfs_set_backup_chunk_root_level(root_backup,
> + btrfs_header_level(info->chunk_root->node));
> +
> + btrfs_set_backup_extent_root(root_backup, info->extent_root->node->start);
> + btrfs_set_backup_extent_root_gen(root_backup,
> + btrfs_header_generation(info->extent_root->node));
> + btrfs_set_backup_extent_root_level(root_backup,
> + btrfs_header_level(info->extent_root->node));
> + /*
> + * we might commit during log recovery, which happens before we set
> + * the fs_root. Make sure it is valid before we fill it in.
> + */
> + if (info->fs_root && info->fs_root->node) {
> + btrfs_set_backup_fs_root(root_backup,
> + info->fs_root->node->start);
> + btrfs_set_backup_fs_root_gen(root_backup,
> + btrfs_header_generation(info->fs_root->node));
> + btrfs_set_backup_fs_root_level(root_backup,
> + btrfs_header_level(info->fs_root->node));
> + }
> +
> + btrfs_set_backup_dev_root(root_backup, info->dev_root->node->start);
> + btrfs_set_backup_dev_root_gen(root_backup,
> + btrfs_header_generation(info->dev_root->node));
> + btrfs_set_backup_dev_root_level(root_backup,
> + btrfs_header_level(info->dev_root->node));
> +
> + btrfs_set_backup_csum_root(root_backup, info->csum_root->node->start);
> + btrfs_set_backup_csum_root_gen(root_backup,
> + btrfs_header_generation(info->csum_root->node));
> + btrfs_set_backup_csum_root_level(root_backup,
> + btrfs_header_level(info->csum_root->node));
> +
> + btrfs_set_backup_total_bytes(root_backup,
> + btrfs_super_total_bytes(info->super_copy));
> + btrfs_set_backup_bytes_used(root_backup,
> + btrfs_super_bytes_used(info->super_copy));
> + btrfs_set_backup_num_devices(root_backup,
> + btrfs_super_num_devices(info->super_copy));
> +};
> +
> int write_all_supers(struct btrfs_fs_info *fs_info)
> {
> struct list_head *head = &fs_info->fs_devices->devices;
> @@ -1630,6 +1707,7 @@ int write_all_supers(struct btrfs_fs_info *fs_info)
> int ret;
> u64 flags;
>
> + backup_super_roots(fs_info);
> sb = fs_info->super_copy;
> dev_item = &sb->dev_item;
> list_for_each_entry(dev, head, dev_list) {
>
