Skip to content

Commit 7216d78

Browse files
adam900710gregkh
adam900710
authored and
gregkh
committed
btrfs: remove btrfs_fs_info::sectors_per_page
[ Upstream commit 619611e ] For the future large folio support, our filemap can have folios with different sizes, thus we can no longer rely on a fixed blocks_per_page value. To prepare for that future, here we do: - Remove btrfs_fs_info::sectors_per_page - Introduce a helper, btrfs_blocks_per_folio() Which uses the folio size to calculate the number of blocks for each folio. - Migrate the existing btrfs_fs_info::sectors_per_page to use that helper There are some exceptions: * Metadata nodesize < page size support In the future, even if we support large folios, we will only allocate a folio that matches our nodesize. Thus we won't have a folio covering multiple metadata unless nodesize < page size. * Existing subpage bitmap dump We use a single unsigned long to store the bitmap. That means until we change the bitmap dumping code, our upper limit for folio size will only be 256K (4K block size, 64 bit unsigned long). * btrfs_is_subpage() check This will be migrated into a future patch. Signed-off-by: Qu Wenruo <wqu@suse.com> Reviewed-by: David Sterba <dsterba@suse.com> Signed-off-by: David Sterba <dsterba@suse.com> Stable-dep-of: e9e3b22 ("btrfs: fix beyond-EOF write handling") Signed-off-by: Sasha Levin <sashal@kernel.org> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
1 parent ced5459 commit 7216d78

4 files changed

Lines changed: 84 additions & 54 deletions

File tree

‎fs/btrfs/disk-io.c‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3320,7 +3320,6 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device
33203320
fs_info->nodesize = nodesize;
33213321
fs_info->sectorsize = sectorsize;
33223322
fs_info->sectorsize_bits = ilog2(sectorsize);
3323-
fs_info->sectors_per_page = (PAGE_SIZE >> fs_info->sectorsize_bits);
33243323
fs_info->csums_per_leaf = BTRFS_MAX_ITEM_SIZE(fs_info) / fs_info->csum_size;
33253324
fs_info->stripesize = stripesize;
33263325

‎fs/btrfs/extent_io.c‎

Lines changed: 15 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1182,7 +1182,7 @@ static bool find_next_delalloc_bitmap(struct folio *folio,
11821182
{
11831183
struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);
11841184
const u64 folio_start = folio_pos(folio);
1185-
const unsigned int bitmap_size = fs_info->sectors_per_page;
1185+
const unsigned int bitmap_size = btrfs_blocks_per_folio(fs_info, folio);
11861186
unsigned int start_bit;
11871187
unsigned int first_zero;
11881188
unsigned int first_set;
@@ -1224,6 +1224,7 @@ static noinline_for_stack int writepage_delalloc(struct btrfs_inode *inode,
12241224
const bool is_subpage = btrfs_is_subpage(fs_info, folio->mapping);
12251225
const u64 page_start = folio_pos(folio);
12261226
const u64 page_end = page_start + folio_size(folio) - 1;
1227+
const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);
12271228
unsigned long delalloc_bitmap = 0;
12281229
/*
12291230
* Save the last found delalloc end. As the delalloc end can go beyond
@@ -1249,13 +1250,13 @@ static noinline_for_stack int writepage_delalloc(struct btrfs_inode *inode,
12491250

12501251
/* Save the dirty bitmap as our submission bitmap will be a subset of it. */
12511252
if (btrfs_is_subpage(fs_info, inode->vfs_inode.i_mapping)) {
1252-
ASSERT(fs_info->sectors_per_page > 1);
1253+
ASSERT(blocks_per_folio > 1);
12531254
btrfs_get_subpage_dirty_bitmap(fs_info, folio, &bio_ctrl->submit_bitmap);
12541255
} else {
12551256
bio_ctrl->submit_bitmap = 1;
12561257
}
12571258

1258-
for_each_set_bit(bit, &bio_ctrl->submit_bitmap, fs_info->sectors_per_page) {
1259+
for_each_set_bit(bit, &bio_ctrl->submit_bitmap, blocks_per_folio) {
12591260
u64 start = page_start + (bit << fs_info->sectorsize_bits);
12601261

12611262
btrfs_folio_set_lock(fs_info, folio, start, fs_info->sectorsize);
@@ -1328,7 +1329,7 @@ static noinline_for_stack int writepage_delalloc(struct btrfs_inode *inode,
13281329
btrfs_root_id(inode->root),
13291330
btrfs_ino(inode),
13301331
folio_pos(folio),
1331-
fs_info->sectors_per_page,
1332+
blocks_per_folio,
13321333
&bio_ctrl->submit_bitmap,
13331334
found_start, found_len, ret);
13341335
} else {
@@ -1373,7 +1374,7 @@ static noinline_for_stack int writepage_delalloc(struct btrfs_inode *inode,
13731374
unsigned int bitmap_size = min(
13741375
(last_finished_delalloc_end - page_start) >>
13751376
fs_info->sectorsize_bits,
1376-
fs_info->sectors_per_page);
1377+
blocks_per_folio);
13771378

13781379
for_each_set_bit(bit, &bio_ctrl->submit_bitmap, bitmap_size)
13791380
btrfs_mark_ordered_io_finished(inode, folio,
@@ -1397,7 +1398,7 @@ static noinline_for_stack int writepage_delalloc(struct btrfs_inode *inode,
13971398
* If all ranges are submitted asynchronously, we just need to account
13981399
* for them here.
13991400
*/
1400-
if (bitmap_empty(&bio_ctrl->submit_bitmap, fs_info->sectors_per_page)) {
1401+
if (bitmap_empty(&bio_ctrl->submit_bitmap, blocks_per_folio)) {
14011402
wbc->nr_to_write -= delalloc_to_write;
14021403
return 1;
14031404
}
@@ -1498,6 +1499,7 @@ static noinline_for_stack int extent_writepage_io(struct btrfs_inode *inode,
14981499
bool submitted_io = false;
14991500
int found_error = 0;
15001501
const u64 folio_start = folio_pos(folio);
1502+
const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);
15011503
u64 cur;
15021504
int bit;
15031505
int ret = 0;
@@ -1516,11 +1518,11 @@ static noinline_for_stack int extent_writepage_io(struct btrfs_inode *inode,
15161518
for (cur = start; cur < start + len; cur += fs_info->sectorsize)
15171519
set_bit((cur - folio_start) >> fs_info->sectorsize_bits, &range_bitmap);
15181520
bitmap_and(&bio_ctrl->submit_bitmap, &bio_ctrl->submit_bitmap, &range_bitmap,
1519-
fs_info->sectors_per_page);
1521+
blocks_per_folio);
15201522

15211523
bio_ctrl->end_io_func = end_bbio_data_write;
15221524

1523-
for_each_set_bit(bit, &bio_ctrl->submit_bitmap, fs_info->sectors_per_page) {
1525+
for_each_set_bit(bit, &bio_ctrl->submit_bitmap, blocks_per_folio) {
15241526
cur = folio_pos(folio) + (bit << fs_info->sectorsize_bits);
15251527

15261528
if (cur >= i_size) {
@@ -1595,6 +1597,7 @@ static int extent_writepage(struct folio *folio, struct btrfs_bio_ctrl *bio_ctrl
15951597
size_t pg_offset;
15961598
loff_t i_size = i_size_read(&inode->vfs_inode);
15971599
unsigned long end_index = i_size >> PAGE_SHIFT;
1600+
const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);
15981601

15991602
trace_extent_writepage(folio, &inode->vfs_inode, bio_ctrl->wbc);
16001603

@@ -1634,7 +1637,7 @@ static int extent_writepage(struct folio *folio, struct btrfs_bio_ctrl *bio_ctrl
16341637
btrfs_err_rl(fs_info,
16351638
"failed to submit blocks, root=%lld inode=%llu folio=%llu submit_bitmap=%*pbl: %d",
16361639
btrfs_root_id(inode->root), btrfs_ino(inode),
1637-
folio_pos(folio), fs_info->sectors_per_page,
1640+
folio_pos(folio), blocks_per_folio,
16381641
&bio_ctrl->submit_bitmap, ret);
16391642

16401643
bio_ctrl->wbc->nr_to_write--;
@@ -1929,9 +1932,10 @@ static int submit_eb_subpage(struct folio *folio, struct writeback_control *wbc)
19291932
u64 folio_start = folio_pos(folio);
19301933
int bit_start = 0;
19311934
int sectors_per_node = fs_info->nodesize >> fs_info->sectorsize_bits;
1935+
const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);
19321936

19331937
/* Lock and write each dirty extent buffers in the range */
1934-
while (bit_start < fs_info->sectors_per_page) {
1938+
while (bit_start < blocks_per_folio) {
19351939
struct btrfs_subpage *subpage = folio_get_private(folio);
19361940
struct extent_buffer *eb;
19371941
unsigned long flags;
@@ -1947,7 +1951,7 @@ static int submit_eb_subpage(struct folio *folio, struct writeback_control *wbc)
19471951
break;
19481952
}
19491953
spin_lock_irqsave(&subpage->lock, flags);
1950-
if (!test_bit(bit_start + btrfs_bitmap_nr_dirty * fs_info->sectors_per_page,
1954+
if (!test_bit(bit_start + btrfs_bitmap_nr_dirty * blocks_per_folio,
19511955
subpage->bitmaps)) {
19521956
spin_unlock_irqrestore(&subpage->lock, flags);
19531957
spin_unlock(&folio->mapping->i_private_lock);

‎fs/btrfs/fs.h‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -708,7 +708,6 @@ struct btrfs_fs_info {
708708
* running.
709709
*/
710710
refcount_t scrub_workers_refcnt;
711-
u32 sectors_per_page;
712711
struct workqueue_struct *scrub_workers;
713712

714713
struct btrfs_discard_ctl discard_ctl;
@@ -976,6 +975,12 @@ static inline u32 count_max_extents(const struct btrfs_fs_info *fs_info, u64 siz
976975
return div_u64(size + fs_info->max_extent_size - 1, fs_info->max_extent_size);
977976
}
978977

978+
static inline unsigned int btrfs_blocks_per_folio(const struct btrfs_fs_info *fs_info,
979+
const struct folio *folio)
980+
{
981+
return folio_size(folio) >> fs_info->sectorsize_bits;
982+
}
983+
979984
bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,
980985
enum btrfs_exclusive_operation type);
981986
bool btrfs_exclop_start_try_lock(struct btrfs_fs_info *fs_info,

‎fs/btrfs/subpage.c‎

Lines changed: 63 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -93,6 +93,9 @@ int btrfs_attach_subpage(const struct btrfs_fs_info *fs_info,
9393
{
9494
struct btrfs_subpage *subpage;
9595

96+
/* For metadata we don't support large folio yet. */
97+
ASSERT(!folio_test_large(folio));
98+
9699
/*
97100
* We have cases like a dummy extent buffer page, which is not mapped
98101
* and doesn't need to be locked.
@@ -134,7 +137,8 @@ struct btrfs_subpage *btrfs_alloc_subpage(const struct btrfs_fs_info *fs_info,
134137
ASSERT(fs_info->sectorsize < PAGE_SIZE);
135138

136139
real_size = struct_size(ret, bitmaps,
137-
BITS_TO_LONGS(btrfs_bitmap_nr_max * fs_info->sectors_per_page));
140+
BITS_TO_LONGS(btrfs_bitmap_nr_max *
141+
(PAGE_SIZE >> fs_info->sectorsize_bits)));
138142
ret = kzalloc(real_size, GFP_NOFS);
139143
if (!ret)
140144
return ERR_PTR(-ENOMEM);
@@ -211,11 +215,13 @@ static void btrfs_subpage_assert(const struct btrfs_fs_info *fs_info,
211215

212216
#define subpage_calc_start_bit(fs_info, folio, name, start, len) \
213217
({ \
214-
unsigned int __start_bit; \
218+
unsigned int __start_bit; \
219+
const unsigned int blocks_per_folio = \
220+
btrfs_blocks_per_folio(fs_info, folio); \
215221
\
216222
btrfs_subpage_assert(fs_info, folio, start, len); \
217223
__start_bit = offset_in_page(start) >> fs_info->sectorsize_bits; \
218-
__start_bit += fs_info->sectors_per_page * btrfs_bitmap_nr_##name; \
224+
__start_bit += blocks_per_folio * btrfs_bitmap_nr_##name; \
219225
__start_bit; \
220226
})
221227

@@ -323,7 +329,8 @@ void btrfs_folio_end_lock_bitmap(const struct btrfs_fs_info *fs_info,
323329
struct folio *folio, unsigned long bitmap)
324330
{
325331
struct btrfs_subpage *subpage = folio_get_private(folio);
326-
const int start_bit = fs_info->sectors_per_page * btrfs_bitmap_nr_locked;
332+
const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);
333+
const int start_bit = blocks_per_folio * btrfs_bitmap_nr_locked;
327334
unsigned long flags;
328335
bool last = false;
329336
int cleared = 0;
@@ -341,7 +348,7 @@ void btrfs_folio_end_lock_bitmap(const struct btrfs_fs_info *fs_info,
341348
}
342349

343350
spin_lock_irqsave(&subpage->lock, flags);
344-
for_each_set_bit(bit, &bitmap, fs_info->sectors_per_page) {
351+
for_each_set_bit(bit, &bitmap, blocks_per_folio) {
345352
if (test_and_clear_bit(bit + start_bit, subpage->bitmaps))
346353
cleared++;
347354
}
@@ -352,15 +359,27 @@ void btrfs_folio_end_lock_bitmap(const struct btrfs_fs_info *fs_info,
352359
folio_unlock(folio);
353360
}
354361

355-
#define subpage_test_bitmap_all_set(fs_info, subpage, name) \
362+
#define subpage_test_bitmap_all_set(fs_info, folio, name) \
363+
({ \
364+
struct btrfs_subpage *subpage = folio_get_private(folio); \
365+
const unsigned int blocks_per_folio = \
366+
btrfs_blocks_per_folio(fs_info, folio); \
367+
\
356368
bitmap_test_range_all_set(subpage->bitmaps, \
357-
fs_info->sectors_per_page * btrfs_bitmap_nr_##name, \
358-
fs_info->sectors_per_page)
369+
blocks_per_folio * btrfs_bitmap_nr_##name, \
370+
blocks_per_folio); \
371+
})
359372

360-
#define subpage_test_bitmap_all_zero(fs_info, subpage, name) \
373+
#define subpage_test_bitmap_all_zero(fs_info, folio, name) \
374+
({ \
375+
struct btrfs_subpage *subpage = folio_get_private(folio); \
376+
const unsigned int blocks_per_folio = \
377+
btrfs_blocks_per_folio(fs_info, folio); \
378+
\
361379
bitmap_test_range_all_zero(subpage->bitmaps, \
362-
fs_info->sectors_per_page * btrfs_bitmap_nr_##name, \
363-
fs_info->sectors_per_page)
380+
blocks_per_folio * btrfs_bitmap_nr_##name, \
381+
blocks_per_folio); \
382+
})
364383

365384
void btrfs_subpage_set_uptodate(const struct btrfs_fs_info *fs_info,
366385
struct folio *folio, u64 start, u32 len)
@@ -372,7 +391,7 @@ void btrfs_subpage_set_uptodate(const struct btrfs_fs_info *fs_info,
372391

373392
spin_lock_irqsave(&subpage->lock, flags);
374393
bitmap_set(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
375-
if (subpage_test_bitmap_all_set(fs_info, subpage, uptodate))
394+
if (subpage_test_bitmap_all_set(fs_info, folio, uptodate))
376395
folio_mark_uptodate(folio);
377396
spin_unlock_irqrestore(&subpage->lock, flags);
378397
}
@@ -426,7 +445,7 @@ bool btrfs_subpage_clear_and_test_dirty(const struct btrfs_fs_info *fs_info,
426445

427446
spin_lock_irqsave(&subpage->lock, flags);
428447
bitmap_clear(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
429-
if (subpage_test_bitmap_all_zero(fs_info, subpage, dirty))
448+
if (subpage_test_bitmap_all_zero(fs_info, folio, dirty))
430449
last = true;
431450
spin_unlock_irqrestore(&subpage->lock, flags);
432451
return last;
@@ -484,7 +503,7 @@ void btrfs_subpage_clear_writeback(const struct btrfs_fs_info *fs_info,
484503

485504
spin_lock_irqsave(&subpage->lock, flags);
486505
bitmap_clear(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
487-
if (subpage_test_bitmap_all_zero(fs_info, subpage, writeback)) {
506+
if (subpage_test_bitmap_all_zero(fs_info, folio, writeback)) {
488507
ASSERT(folio_test_writeback(folio));
489508
folio_end_writeback(folio);
490509
}
@@ -515,7 +534,7 @@ void btrfs_subpage_clear_ordered(const struct btrfs_fs_info *fs_info,
515534

516535
spin_lock_irqsave(&subpage->lock, flags);
517536
bitmap_clear(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
518-
if (subpage_test_bitmap_all_zero(fs_info, subpage, ordered))
537+
if (subpage_test_bitmap_all_zero(fs_info, folio, ordered))
519538
folio_clear_ordered(folio);
520539
spin_unlock_irqrestore(&subpage->lock, flags);
521540
}
@@ -530,7 +549,7 @@ void btrfs_subpage_set_checked(const struct btrfs_fs_info *fs_info,
530549

531550
spin_lock_irqsave(&subpage->lock, flags);
532551
bitmap_set(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
533-
if (subpage_test_bitmap_all_set(fs_info, subpage, checked))
552+
if (subpage_test_bitmap_all_set(fs_info, folio, checked))
534553
folio_set_checked(folio);
535554
spin_unlock_irqrestore(&subpage->lock, flags);
536555
}
@@ -652,26 +671,29 @@ IMPLEMENT_BTRFS_PAGE_OPS(ordered, folio_set_ordered, folio_clear_ordered,
652671
IMPLEMENT_BTRFS_PAGE_OPS(checked, folio_set_checked, folio_clear_checked,
653672
folio_test_checked);
654673

655-
#define GET_SUBPAGE_BITMAP(subpage, fs_info, name, dst) \
674+
#define GET_SUBPAGE_BITMAP(fs_info, folio, name, dst) \
656675
{ \
657-
const int sectors_per_page = fs_info->sectors_per_page; \
676+
const unsigned int blocks_per_folio = \
677+
btrfs_blocks_per_folio(fs_info, folio); \
678+
const struct btrfs_subpage *subpage = folio_get_private(folio); \
658679
\
659-
ASSERT(sectors_per_page < BITS_PER_LONG); \
680+
ASSERT(blocks_per_folio < BITS_PER_LONG); \
660681
*dst = bitmap_read(subpage->bitmaps, \
661-
sectors_per_page * btrfs_bitmap_nr_##name, \
662-
sectors_per_page); \
682+
blocks_per_folio * btrfs_bitmap_nr_##name, \
683+
blocks_per_folio); \
663684
}
664685

665686
#define SUBPAGE_DUMP_BITMAP(fs_info, folio, name, start, len) \
666687
{ \
667-
const struct btrfs_subpage *subpage = folio_get_private(folio); \
668688
unsigned long bitmap; \
689+
const unsigned int blocks_per_folio = \
690+
btrfs_blocks_per_folio(fs_info, folio); \
669691
\
670-
GET_SUBPAGE_BITMAP(subpage, fs_info, name, &bitmap); \
692+
GET_SUBPAGE_BITMAP(fs_info, folio, name, &bitmap); \
671693
btrfs_warn(fs_info, \
672694
"dumpping bitmap start=%llu len=%u folio=%llu " #name "_bitmap=%*pbl", \
673695
start, len, folio_pos(folio), \
674-
fs_info->sectors_per_page, &bitmap); \
696+
blocks_per_folio, &bitmap); \
675697
}
676698

677699
/*
@@ -738,15 +760,15 @@ void btrfs_folio_set_lock(const struct btrfs_fs_info *fs_info,
738760
}
739761
bitmap_set(subpage->bitmaps, start_bit, nbits);
740762
ret = atomic_add_return(nbits, &subpage->nr_locked);
741-
ASSERT(ret <= fs_info->sectors_per_page);
763+
ASSERT(ret <= btrfs_blocks_per_folio(fs_info, folio));
742764
spin_unlock_irqrestore(&subpage->lock, flags);
743765
}
744766

745767
void __cold btrfs_subpage_dump_bitmap(const struct btrfs_fs_info *fs_info,
746768
struct folio *folio, u64 start, u32 len)
747769
{
748770
struct btrfs_subpage *subpage;
749-
const u32 sectors_per_page = fs_info->sectors_per_page;
771+
const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);
750772
unsigned long uptodate_bitmap;
751773
unsigned long dirty_bitmap;
752774
unsigned long writeback_bitmap;
@@ -756,28 +778,28 @@ void __cold btrfs_subpage_dump_bitmap(const struct btrfs_fs_info *fs_info,
756778
unsigned long flags;
757779

758780
ASSERT(folio_test_private(folio) && folio_get_private(folio));
759-
ASSERT(sectors_per_page > 1);
781+
ASSERT(blocks_per_folio > 1);
760782
subpage = folio_get_private(folio);
761783

762784
spin_lock_irqsave(&subpage->lock, flags);
763-
GET_SUBPAGE_BITMAP(subpage, fs_info, uptodate, &uptodate_bitmap);
764-
GET_SUBPAGE_BITMAP(subpage, fs_info, dirty, &dirty_bitmap);
765-
GET_SUBPAGE_BITMAP(subpage, fs_info, writeback, &writeback_bitmap);
766-
GET_SUBPAGE_BITMAP(subpage, fs_info, ordered, &ordered_bitmap);
767-
GET_SUBPAGE_BITMAP(subpage, fs_info, checked, &checked_bitmap);
768-
GET_SUBPAGE_BITMAP(subpage, fs_info, locked, &locked_bitmap);
785+
GET_SUBPAGE_BITMAP(fs_info, folio, uptodate, &uptodate_bitmap);
786+
GET_SUBPAGE_BITMAP(fs_info, folio, dirty, &dirty_bitmap);
787+
GET_SUBPAGE_BITMAP(fs_info, folio, writeback, &writeback_bitmap);
788+
GET_SUBPAGE_BITMAP(fs_info, folio, ordered, &ordered_bitmap);
789+
GET_SUBPAGE_BITMAP(fs_info, folio, checked, &checked_bitmap);
790+
GET_SUBPAGE_BITMAP(fs_info, folio, locked, &locked_bitmap);
769791
spin_unlock_irqrestore(&subpage->lock, flags);
770792

771793
dump_page(folio_page(folio, 0), "btrfs subpage dump");
772794
btrfs_warn(fs_info,
773795
"start=%llu len=%u page=%llu, bitmaps uptodate=%*pbl dirty=%*pbl locked=%*pbl writeback=%*pbl ordered=%*pbl checked=%*pbl",
774796
start, len, folio_pos(folio),
775-
sectors_per_page, &uptodate_bitmap,
776-
sectors_per_page, &dirty_bitmap,
777-
sectors_per_page, &locked_bitmap,
778-
sectors_per_page, &writeback_bitmap,
779-
sectors_per_page, &ordered_bitmap,
780-
sectors_per_page, &checked_bitmap);
797+
blocks_per_folio, &uptodate_bitmap,
798+
blocks_per_folio, &dirty_bitmap,
799+
blocks_per_folio, &locked_bitmap,
800+
blocks_per_folio, &writeback_bitmap,
801+
blocks_per_folio, &ordered_bitmap,
802+
blocks_per_folio, &checked_bitmap);
781803
}
782804

783805
void btrfs_get_subpage_dirty_bitmap(struct btrfs_fs_info *fs_info,
@@ -788,10 +810,10 @@ void btrfs_get_subpage_dirty_bitmap(struct btrfs_fs_info *fs_info,
788810
unsigned long flags;
789811

790812
ASSERT(folio_test_private(folio) && folio_get_private(folio));
791-
ASSERT(fs_info->sectors_per_page > 1);
813+
ASSERT(btrfs_blocks_per_folio(fs_info, folio) > 1);
792814
subpage = folio_get_private(folio);
793815

794816
spin_lock_irqsave(&subpage->lock, flags);
795-
GET_SUBPAGE_BITMAP(subpage, fs_info, dirty, ret_bitmap);
817+
GET_SUBPAGE_BITMAP(fs_info, folio, dirty, ret_bitmap);
796818
spin_unlock_irqrestore(&subpage->lock, flags);
797819
}

0 commit comments

Comments
 (0)