github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-07 06:17:02 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

btrfs: simplify heuristic_collect_sample() to handle large folios better

Browse Source 
Currently heuristic_collect_sample() is purely page size based, and it
has a lot of extra handling just inside the page.

However we already have large folio support, there is no need to look up
the same folio repeatedly.

Simplify the handling by:

- Use @cur as the iterator instead of page index

- Handle the sample copying on a per-folio basis
  Although kmap_local_folio() requires an offset to handle HIGHMEM
  page mapping, we have rejected large folios for HIGHMEM systems
  completely.

  So we can safely handle all sample copying inside the folio in one
  go.

- Remove unnecessary unaligned range handling
  All the range passed in should be block aligned, thus there is no need
  to handle cases where sample crosses the block boundary.

Reviewed-by: Boris Burkov <boris@bur.io>
Signed-off-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
Qu Wenruo 2026-09-10 11:35:53 +09:30 committed by David Sterba
parent 44edf5160b
commit 70fc94d2e0
1 changed files with 16 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
fs/btrfs/compression.c
View File

@ -1489,10 +1489,8 @@ static void heuristic_collect_sample(struct inode *inode, u64 start, u64 end,
struct heuristic_ws *ws)
{
const u32 blocksize = BTRFS_I(inode)->root->fs_info->sectorsize;
struct folio *folio;
u64 index, index_end;
u32 i, curr_sample_pos;
u8 *in_data;
u64 cur = start;
u32 curr_sample_pos = 0;
ASSERT(IS_ALIGNED(start, blocksize) && IS_ALIGNED(end + 1, blocksize));
@ -1508,33 +1506,27 @@ static void heuristic_collect_sample(struct inode *inode, u64 start, u64 end,
if (end + 1 - start > BTRFS_MAX_UNCOMPRESSED)
end = start + BTRFS_MAX_UNCOMPRESSED - 1;
index = start >> PAGE_SHIFT;
index_end = end >> PAGE_SHIFT;
while (cur < end) {
struct folio *folio;
void *in_data;
u64 next_pos;
curr_sample_pos = 0;
while (index <= index_end) {
folio = filemap_get_folio(inode->i_mapping, index);
folio = filemap_get_folio(inode->i_mapping, cur >> PAGE_SHIFT);
/* All folios inside the range should exist and be locked. */
ASSERT(!IS_ERR(folio));
in_data = kmap_local_folio(folio,
offset_in_folio(folio, index << PAGE_SHIFT));
/* Handle case where the start is not aligned to PAGE_SIZE */
i = start % PAGE_SIZE;
while (i < PAGE_SIZE - SAMPLING_READ_SIZE) {
/* Don't sample any garbage from the last page */
if (start > end + 1 - SAMPLING_READ_SIZE)
break;
memcpy(&ws->sample[curr_sample_pos], &in_data[i],
SAMPLING_READ_SIZE);
i += SAMPLING_INTERVAL;
start += SAMPLING_INTERVAL;
next_pos = min_t(u64, end + 1, folio_next_pos(folio));
in_data = kmap_local_folio(folio, 0);
for (; cur < next_pos; cur += SAMPLING_INTERVAL) {
memcpy(&ws->sample[curr_sample_pos],
in_data + offset_in_folio(folio, cur),
SAMPLING_READ_SIZE);
curr_sample_pos += SAMPLING_READ_SIZE;
}
kunmap_local(in_data);
folio_put(folio);
index++;
cur = next_pos;
}
ws->sample_size = curr_sample_pos;
}