korg/e2fsprogs
0
0
Fork 0
mirror of https://git.kernel.org/pub/scm/fs/ext2/e2fsprogs.git synced 2024-11-23 18:14:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

AOSP: e2fsdroid: Don't skip unusable blocks in BaseFS.

Browse Source 
Currently, basefs_allocator will iterate through blocks owned by an
inode until it finds a block that is free. This effectively ignores the
logical to physical block mapping, which can lead to a bigger delta in
the final image.

An example of how this can happen is if the BaseFS has a deduplicated
block (D), that is not deduplicated in the new image:

  Old image: 1 2 3 D 4 5
  New image: 1 2 3 ? 4 5

If the allocator sees that "D" is not usable, and skips to block "4",
we will have a non-ideal assignment.

  Bad image: 1 2 3 4 5 ?

This patch refactors get_next_block() to acquire at most one block. It's
called a single time, and then only called in a loop if absolutely no
blocks can be acquired from anywhere else.

In a Virtual A/B simulation, this reduces the COW snapshot size by about
90MB.

Bug: 139201772
Test: manual test
Change-Id: I354f0dee1ee191dba0e1f90491ed591dba388f7f
From AOSP commit: a495b54f89b2ec0e46be8e3564e4852c6434687c
This commit is contained in:
David Anderson 2020-02-14 12:44:48 -08:00 committed by Theodore Ts'o
parent 58ecfa7f51
commit c25ec972c9
1 changed files with 39 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
contrib/android/basefs_allocator.c
View File

@ -216,29 +216,30 @@ out:
}
/* Try and acquire the next usable block from the Base FS map. */
static int get_next_block(ext2_filsys fs, struct base_fs_allocator *allocator,
struct block_range_list* list, blk64_t *ret)
static errcode_t get_next_block(ext2_filsys fs, struct base_fs_allocator *allocator,
struct block_range_list* list, blk64_t *ret)
{
blk64_t block;
ext2fs_block_bitmap exclusive_map = allocator->exclusive_block_map;
ext2fs_block_bitmap dedup_map = allocator->dedup_block_map;
while (list->head) {
block = consume_next_block(list);
if (block >= ext2fs_blocks_count(fs->super))
continue;
if (ext2fs_test_block_bitmap2(exclusive_map, block)) {
ext2fs_unmark_block_bitmap2(exclusive_map, block);
*ret = block;
return 0;
}
if (ext2fs_test_block_bitmap2(dedup_map, block)) {
ext2fs_unmark_block_bitmap2(dedup_map, block);
*ret = block;
return 0;
}
if (!list->head)
return EXT2_ET_BLOCK_ALLOC_FAIL;
block = consume_next_block(list);
if (block >= ext2fs_blocks_count(fs->super))
return EXT2_ET_BLOCK_ALLOC_FAIL;
if (ext2fs_test_block_bitmap2(exclusive_map, block)) {
ext2fs_unmark_block_bitmap2(exclusive_map, block);
*ret = block;
return 0;
}
return -1;
if (ext2fs_test_block_bitmap2(dedup_map, block)) {
ext2fs_unmark_block_bitmap2(dedup_map, block);
*ret = block;
return 0;
}
return EXT2_ET_BLOCK_ALLOC_FAIL;
}
/*
@ -299,17 +300,28 @@ static errcode_t basefs_block_allocator(ext2_filsys fs, blk64_t goal,
ext2fs_mark_block_bitmap2(fs->block_map, *ret);
return 0;
}
if (retval == EXT2_ET_BLOCK_ALLOC_FAIL) {
/* Try to steal a block from the dedup pool. */
retval = ext2fs_find_first_set_block_bitmap2(dedup_map,
fs->super->s_first_data_block,
ext2fs_blocks_count(fs->super) - 1, ret);
if (!retval) {
ext2fs_unmark_block_bitmap2(dedup_map, *ret);
return 0;
}
if (retval != EXT2_ET_BLOCK_ALLOC_FAIL)
return retval;
/* Try to steal a block from the dedup pool. */
retval = ext2fs_find_first_set_block_bitmap2(dedup_map,
fs->super->s_first_data_block,
ext2fs_blocks_count(fs->super) - 1, ret);
if (!retval) {
ext2fs_unmark_block_bitmap2(dedup_map, *ret);
return 0;
}
return retval;
/*
* As a last resort, take any block from our file's list. This
* risks bloating the diff, but means we are more likely to
* successfully build an image.
*/
while (e->blocks.head) {
if (!get_next_block(fs, allocator, &e->blocks, ret))
return 0;
}
return EXT2_ET_BLOCK_ALLOC_FAIL;
}
void base_fs_alloc_cleanup(ext2_filsys fs)