| Message ID | 20210116071533.105780-9-wqu@suse.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | btrfs: add read-only support for subpage sector size | expand |
On Sat, Jan 16, 2021 at 03:15:23PM +0800, Qu Wenruo wrote: > This patch introduce the following functions to handle btrfs subpage > uptodate status: > - btrfs_subpage_set_uptodate() > - btrfs_subpage_clear_uptodate() > - btrfs_subpage_test_uptodate() > Those helpers can only be called when the range is ensured to be > inside the page. > > - btrfs_page_set_uptodate() > - btrfs_page_clear_uptodate() > - btrfs_page_test_uptodate() > Those helpers can handle both regular sector size and subpage without > problem. > Although caller should still ensure that the range is inside the page. > > Signed-off-by: Qu Wenruo <wqu@suse.com> > --- > fs/btrfs/subpage.h | 115 +++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 115 insertions(+) > > diff --git a/fs/btrfs/subpage.h b/fs/btrfs/subpage.h > index d8b34879368d..3373ef4ffec1 100644 > --- a/fs/btrfs/subpage.h > +++ b/fs/btrfs/subpage.h > @@ -23,6 +23,7 @@ > struct btrfs_subpage { > /* Common members for both data and metadata pages */ > spinlock_t lock; > + u16 uptodate_bitmap; > union { > /* Structures only used by metadata */ > bool under_alloc; > @@ -78,4 +79,118 @@ static inline void btrfs_page_end_meta_alloc(struct btrfs_fs_info *fs_info, > int btrfs_attach_subpage(struct btrfs_fs_info *fs_info, struct page *page); > void btrfs_detach_subpage(struct btrfs_fs_info *fs_info, struct page *page); > > +/* > + * Convert the [start, start + len) range into a u16 bitmap > + * > + * E.g. if start == page_offset() + 16K, len = 16K, we get 0x00f0. > + */ > +static inline u16 btrfs_subpage_calc_bitmap(struct btrfs_fs_info *fs_info, All the API functions should use const for data that are only read, fs_info in this case at least. > + struct page *page, u64 start, u32 len) > +{ > + int bit_start = offset_in_page(start) >> fs_info->sectorsize_bits; > + int nbits = len >> fs_info->sectorsize_bits; > + > + /* Basic checks */ > + ASSERT(PagePrivate(page) && page->private); > + ASSERT(IS_ALIGNED(start, fs_info->sectorsize) && > + IS_ALIGNED(len, fs_info->sectorsize)); > + > + /* > + * The range check only works for mapped page, we can > + * still have unampped page like dummy extent buffer pages. > + */ > + if (page->mapping) > + ASSERT(page_offset(page) <= start && > + start + len <= page_offset(page) + PAGE_SIZE); > + /* > + * Here nbits can be 16, thus can go beyond u16 range. Here we make the > + * first left shift to be calculated in unsigned long (u32), then > + * truncate the result to u16. > + */ > + return (u16)(((1UL << nbits) - 1) << bit_start); > +} > + > +static inline void btrfs_subpage_set_uptodate(struct btrfs_fs_info *fs_info, > + struct page *page, u64 start, u32 len) > +{ > + struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; > + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); > + unsigned long flags; > + > + spin_lock_irqsave(&subpage->lock, flags); > + subpage->uptodate_bitmap |= tmp; > + if (subpage->uptodate_bitmap == U16_MAX) > + SetPageUptodate(page); > + spin_unlock_irqrestore(&subpage->lock, flags); > +} > + > +static inline void btrfs_subpage_clear_uptodate(struct btrfs_fs_info *fs_info, > + struct page *page, u64 start, u32 len) > +{ > + struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; > + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); > + unsigned long flags; > + > + spin_lock_irqsave(&subpage->lock, flags); > + subpage->uptodate_bitmap &= ~tmp; > + ClearPageUptodate(page); > + spin_unlock_irqrestore(&subpage->lock, flags); > +} > + > +/* > + * Unlike set/clear which is dependent on each page status, for test all bits > + * are tested in the same way. > + */ > +#define DECLARE_BTRFS_SUBPAGE_TEST_OP(name) \ > +static inline bool btrfs_subpage_test_##name(struct btrfs_fs_info *fs_info, \ > + struct page *page, u64 start, u32 len) \ > +{ \ > + struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; \ > + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); \ > + unsigned long flags; \ > + bool ret; \ > + \ > + spin_lock_irqsave(&subpage->lock, flags); \ > + ret = ((subpage->name##_bitmap & tmp) == tmp); \ > + spin_unlock_irqrestore(&subpage->lock, flags); \ > + return ret; \ > +} > +DECLARE_BTRFS_SUBPAGE_TEST_OP(uptodate); > + > +/* > + * Note that, in selftest, especially extent-io-tests, we can have empty > + * fs_info passed in. > + * Thankfully in selftest, we only test sectorsize == PAGE_SIZE cases so far, > + * thus we can fall back to regular sectorsize branch. > + */ > +#define DECLARE_BTRFS_PAGE_OPS(name, set_page_func, clear_page_func, \ > + test_page_func) \ > +static inline void btrfs_page_set_##name(struct btrfs_fs_info *fs_info, \ > + struct page *page, u64 start, u32 len) \ > +{ \ > + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \ > + set_page_func(page); \ > + return; \ > + } \ > + btrfs_subpage_set_##name(fs_info, page, start, len); \ > +} \ > +static inline void btrfs_page_clear_##name(struct btrfs_fs_info *fs_info, \ > + struct page *page, u64 start, u32 len) \ > +{ \ > + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \ > + clear_page_func(page); \ > + return; \ > + } \ > + btrfs_subpage_clear_##name(fs_info, page, start, len); \ > +} \ > +static inline bool btrfs_page_test_##name(struct btrfs_fs_info *fs_info, \ > + struct page *page, u64 start, u32 len) \ > +{ \ > + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) \ > + return test_page_func(page); \ > + return btrfs_subpage_test_##name(fs_info, page, start, len); \ > +} > +DECLARE_BTRFS_PAGE_OPS(uptodate, SetPageUptodate, ClearPageUptodate, > + PageUptodate); > + > #endif /* BTRFS_SUBPAGE_H */ > -- > 2.30.0
On 1/16/21 2:15 AM, Qu Wenruo wrote: > This patch introduce the following functions to handle btrfs subpage > uptodate status: > - btrfs_subpage_set_uptodate() > - btrfs_subpage_clear_uptodate() > - btrfs_subpage_test_uptodate() > Those helpers can only be called when the range is ensured to be > inside the page. > > - btrfs_page_set_uptodate() > - btrfs_page_clear_uptodate() > - btrfs_page_test_uptodate() > Those helpers can handle both regular sector size and subpage without > problem. > Although caller should still ensure that the range is inside the page. > > Signed-off-by: Qu Wenruo <wqu@suse.com> > --- > fs/btrfs/subpage.h | 115 +++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 115 insertions(+) > > diff --git a/fs/btrfs/subpage.h b/fs/btrfs/subpage.h > index d8b34879368d..3373ef4ffec1 100644 > --- a/fs/btrfs/subpage.h > +++ b/fs/btrfs/subpage.h > @@ -23,6 +23,7 @@ > struct btrfs_subpage { > /* Common members for both data and metadata pages */ > spinlock_t lock; > + u16 uptodate_bitmap; > union { > /* Structures only used by metadata */ > bool under_alloc; > @@ -78,4 +79,118 @@ static inline void btrfs_page_end_meta_alloc(struct btrfs_fs_info *fs_info, > int btrfs_attach_subpage(struct btrfs_fs_info *fs_info, struct page *page); > void btrfs_detach_subpage(struct btrfs_fs_info *fs_info, struct page *page); > > +/* > + * Convert the [start, start + len) range into a u16 bitmap > + * > + * E.g. if start == page_offset() + 16K, len = 16K, we get 0x00f0. > + */ > +static inline u16 btrfs_subpage_calc_bitmap(struct btrfs_fs_info *fs_info, > + struct page *page, u64 start, u32 len) > +{ > + int bit_start = offset_in_page(start) >> fs_info->sectorsize_bits; > + int nbits = len >> fs_info->sectorsize_bits; > + > + /* Basic checks */ > + ASSERT(PagePrivate(page) && page->private); > + ASSERT(IS_ALIGNED(start, fs_info->sectorsize) && > + IS_ALIGNED(len, fs_info->sectorsize)); > + > + /* > + * The range check only works for mapped page, we can > + * still have unampped page like dummy extent buffer pages. > + */ > + if (page->mapping) > + ASSERT(page_offset(page) <= start && > + start + len <= page_offset(page) + PAGE_SIZE); Once you gate the helpers on UNMAPPED you'll always have page->mapping set and you can drop the if statement. Thanks, Josef
On 1/16/21 2:15 AM, Qu Wenruo wrote: > This patch introduce the following functions to handle btrfs subpage > uptodate status: > - btrfs_subpage_set_uptodate() > - btrfs_subpage_clear_uptodate() > - btrfs_subpage_test_uptodate() > Those helpers can only be called when the range is ensured to be > inside the page. > > - btrfs_page_set_uptodate() > - btrfs_page_clear_uptodate() > - btrfs_page_test_uptodate() > Those helpers can handle both regular sector size and subpage without > problem. > Although caller should still ensure that the range is inside the page. > > Signed-off-by: Qu Wenruo <wqu@suse.com> > --- > fs/btrfs/subpage.h | 115 +++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 115 insertions(+) > > diff --git a/fs/btrfs/subpage.h b/fs/btrfs/subpage.h > index d8b34879368d..3373ef4ffec1 100644 > --- a/fs/btrfs/subpage.h > +++ b/fs/btrfs/subpage.h > @@ -23,6 +23,7 @@ > struct btrfs_subpage { > /* Common members for both data and metadata pages */ > spinlock_t lock; > + u16 uptodate_bitmap; > union { > /* Structures only used by metadata */ > bool under_alloc; > @@ -78,4 +79,118 @@ static inline void btrfs_page_end_meta_alloc(struct btrfs_fs_info *fs_info, > int btrfs_attach_subpage(struct btrfs_fs_info *fs_info, struct page *page); > void btrfs_detach_subpage(struct btrfs_fs_info *fs_info, struct page *page); > > +/* > + * Convert the [start, start + len) range into a u16 bitmap > + * > + * E.g. if start == page_offset() + 16K, len = 16K, we get 0x00f0. > + */ > +static inline u16 btrfs_subpage_calc_bitmap(struct btrfs_fs_info *fs_info, > + struct page *page, u64 start, u32 len) > +{ > + int bit_start = offset_in_page(start) >> fs_info->sectorsize_bits; > + int nbits = len >> fs_info->sectorsize_bits; > + > + /* Basic checks */ > + ASSERT(PagePrivate(page) && page->private); > + ASSERT(IS_ALIGNED(start, fs_info->sectorsize) && > + IS_ALIGNED(len, fs_info->sectorsize)); > + > + /* > + * The range check only works for mapped page, we can > + * still have unampped page like dummy extent buffer pages. > + */ > + if (page->mapping) > + ASSERT(page_offset(page) <= start && > + start + len <= page_offset(page) + PAGE_SIZE); > + /* > + * Here nbits can be 16, thus can go beyond u16 range. Here we make the > + * first left shift to be calculated in unsigned long (u32), then > + * truncate the result to u16. > + */ > + return (u16)(((1UL << nbits) - 1) << bit_start); > +} > + > +static inline void btrfs_subpage_set_uptodate(struct btrfs_fs_info *fs_info, > + struct page *page, u64 start, u32 len) > +{ > + struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; > + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); > + unsigned long flags; > + > + spin_lock_irqsave(&subpage->lock, flags); > + subpage->uptodate_bitmap |= tmp; > + if (subpage->uptodate_bitmap == U16_MAX) > + SetPageUptodate(page); > + spin_unlock_irqrestore(&subpage->lock, flags); > +} > + > +static inline void btrfs_subpage_clear_uptodate(struct btrfs_fs_info *fs_info, > + struct page *page, u64 start, u32 len) > +{ > + struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; > + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); > + unsigned long flags; > + > + spin_lock_irqsave(&subpage->lock, flags); > + subpage->uptodate_bitmap &= ~tmp; > + ClearPageUptodate(page); > + spin_unlock_irqrestore(&subpage->lock, flags); > +} > + > +/* > + * Unlike set/clear which is dependent on each page status, for test all bits > + * are tested in the same way. > + */ > +#define DECLARE_BTRFS_SUBPAGE_TEST_OP(name) \ > +static inline bool btrfs_subpage_test_##name(struct btrfs_fs_info *fs_info, \ > + struct page *page, u64 start, u32 len) \ > +{ \ > + struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; \ > + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); \ > + unsigned long flags; \ > + bool ret; \ > + \ > + spin_lock_irqsave(&subpage->lock, flags); \ > + ret = ((subpage->name##_bitmap & tmp) == tmp); \ > + spin_unlock_irqrestore(&subpage->lock, flags); \ > + return ret; \ > +} > +DECLARE_BTRFS_SUBPAGE_TEST_OP(uptodate); > + > +/* > + * Note that, in selftest, especially extent-io-tests, we can have empty > + * fs_info passed in. > + * Thankfully in selftest, we only test sectorsize == PAGE_SIZE cases so far, > + * thus we can fall back to regular sectorsize branch. > + */ > +#define DECLARE_BTRFS_PAGE_OPS(name, set_page_func, clear_page_func, \ > + test_page_func) \ > +static inline void btrfs_page_set_##name(struct btrfs_fs_info *fs_info, \ > + struct page *page, u64 start, u32 len) \ > +{ \ > + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \ > + set_page_func(page); \ > + return; \ > + } \ > + btrfs_subpage_set_##name(fs_info, page, start, len); \ > +} \ > +static inline void btrfs_page_clear_##name(struct btrfs_fs_info *fs_info, \ > + struct page *page, u64 start, u32 len) \ > +{ \ > + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \ > + clear_page_func(page); \ > + return; \ > + } \ > + btrfs_subpage_clear_##name(fs_info, page, start, len); \ > +} \ > +static inline bool btrfs_page_test_##name(struct btrfs_fs_info *fs_info, \ > + struct page *page, u64 start, u32 len) \ > +{ \ > + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) \ > + return test_page_func(page); \ > + return btrfs_subpage_test_##name(fs_info, page, start, len); \ > +} Another thing I just realized is you're doing this btrfs_page_set_uptodate(fs_info, page, eb->start, eb->len); but we default to a nodesize > PAGE_SIZE on x86. This is fine, because you're checking fs_info->sectorsize == PAGE_SIZE, which will mean we do the right thing. But what happens if fs_info->nodesize < PAGE_SIZE && fs_info->sectorsize == PAGE_SIZE? We by default have fs'es that ->nodesize != ->sectorsize, so really what we should be doing is checking if len == PAGE_SIZE here, but then you need to take into account the case that eb->len > PAGE_SIZE. Fix this to do the right thing in either of those cases. Thanks, Josef
On 2021/1/20 下午11:00, Josef Bacik wrote: > On 1/16/21 2:15 AM, Qu Wenruo wrote: >> This patch introduce the following functions to handle btrfs subpage >> uptodate status: >> - btrfs_subpage_set_uptodate() >> - btrfs_subpage_clear_uptodate() >> - btrfs_subpage_test_uptodate() >> Those helpers can only be called when the range is ensured to be >> inside the page. >> >> - btrfs_page_set_uptodate() >> - btrfs_page_clear_uptodate() >> - btrfs_page_test_uptodate() >> Those helpers can handle both regular sector size and subpage without >> problem. >> Although caller should still ensure that the range is inside the page. >> >> Signed-off-by: Qu Wenruo <wqu@suse.com> >> --- >> fs/btrfs/subpage.h | 115 +++++++++++++++++++++++++++++++++++++++++++++ >> 1 file changed, 115 insertions(+) >> >> diff --git a/fs/btrfs/subpage.h b/fs/btrfs/subpage.h >> index d8b34879368d..3373ef4ffec1 100644 >> --- a/fs/btrfs/subpage.h >> +++ b/fs/btrfs/subpage.h >> @@ -23,6 +23,7 @@ >> struct btrfs_subpage { >> /* Common members for both data and metadata pages */ >> spinlock_t lock; >> + u16 uptodate_bitmap; >> union { >> /* Structures only used by metadata */ >> bool under_alloc; >> @@ -78,4 +79,118 @@ static inline void >> btrfs_page_end_meta_alloc(struct btrfs_fs_info *fs_info, >> int btrfs_attach_subpage(struct btrfs_fs_info *fs_info, struct page >> *page); >> void btrfs_detach_subpage(struct btrfs_fs_info *fs_info, struct page >> *page); >> +/* >> + * Convert the [start, start + len) range into a u16 bitmap >> + * >> + * E.g. if start == page_offset() + 16K, len = 16K, we get 0x00f0. >> + */ >> +static inline u16 btrfs_subpage_calc_bitmap(struct btrfs_fs_info >> *fs_info, >> + struct page *page, u64 start, u32 len) >> +{ >> + int bit_start = offset_in_page(start) >> fs_info->sectorsize_bits; >> + int nbits = len >> fs_info->sectorsize_bits; >> + >> + /* Basic checks */ >> + ASSERT(PagePrivate(page) && page->private); >> + ASSERT(IS_ALIGNED(start, fs_info->sectorsize) && >> + IS_ALIGNED(len, fs_info->sectorsize)); >> + >> + /* >> + * The range check only works for mapped page, we can >> + * still have unampped page like dummy extent buffer pages. >> + */ >> + if (page->mapping) >> + ASSERT(page_offset(page) <= start && >> + start + len <= page_offset(page) + PAGE_SIZE); >> + /* >> + * Here nbits can be 16, thus can go beyond u16 range. Here we >> make the >> + * first left shift to be calculated in unsigned long (u32), then >> + * truncate the result to u16. >> + */ >> + return (u16)(((1UL << nbits) - 1) << bit_start); >> +} >> + >> +static inline void btrfs_subpage_set_uptodate(struct btrfs_fs_info >> *fs_info, >> + struct page *page, u64 start, u32 len) >> +{ >> + struct btrfs_subpage *subpage = (struct btrfs_subpage >> *)page->private; >> + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); >> + unsigned long flags; >> + >> + spin_lock_irqsave(&subpage->lock, flags); >> + subpage->uptodate_bitmap |= tmp; >> + if (subpage->uptodate_bitmap == U16_MAX) >> + SetPageUptodate(page); >> + spin_unlock_irqrestore(&subpage->lock, flags); >> +} >> + >> +static inline void btrfs_subpage_clear_uptodate(struct btrfs_fs_info >> *fs_info, >> + struct page *page, u64 start, u32 len) >> +{ >> + struct btrfs_subpage *subpage = (struct btrfs_subpage >> *)page->private; >> + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); >> + unsigned long flags; >> + >> + spin_lock_irqsave(&subpage->lock, flags); >> + subpage->uptodate_bitmap &= ~tmp; >> + ClearPageUptodate(page); >> + spin_unlock_irqrestore(&subpage->lock, flags); >> +} >> + >> +/* >> + * Unlike set/clear which is dependent on each page status, for test >> all bits >> + * are tested in the same way. >> + */ >> +#define DECLARE_BTRFS_SUBPAGE_TEST_OP(name) \ >> +static inline bool btrfs_subpage_test_##name(struct btrfs_fs_info >> *fs_info, \ >> + struct page *page, u64 start, u32 len) \ >> +{ \ >> + struct btrfs_subpage *subpage = (struct btrfs_subpage >> *)page->private; \ >> + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); \ >> + unsigned long flags; \ >> + bool ret; \ >> + \ >> + spin_lock_irqsave(&subpage->lock, flags); \ >> + ret = ((subpage->name##_bitmap & tmp) == tmp); \ >> + spin_unlock_irqrestore(&subpage->lock, flags); \ >> + return ret; \ >> +} >> +DECLARE_BTRFS_SUBPAGE_TEST_OP(uptodate); >> + >> +/* >> + * Note that, in selftest, especially extent-io-tests, we can have empty >> + * fs_info passed in. >> + * Thankfully in selftest, we only test sectorsize == PAGE_SIZE cases >> so far, >> + * thus we can fall back to regular sectorsize branch. >> + */ >> +#define DECLARE_BTRFS_PAGE_OPS(name, set_page_func, >> clear_page_func, \ >> + test_page_func) \ >> +static inline void btrfs_page_set_##name(struct btrfs_fs_info >> *fs_info, \ >> + struct page *page, u64 start, u32 len) \ >> +{ \ >> + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \ >> + set_page_func(page); \ >> + return; \ >> + } \ >> + btrfs_subpage_set_##name(fs_info, page, start, len); \ >> +} \ >> +static inline void btrfs_page_clear_##name(struct btrfs_fs_info >> *fs_info, \ >> + struct page *page, u64 start, u32 len) \ >> +{ \ >> + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \ >> + clear_page_func(page); \ >> + return; \ >> + } \ >> + btrfs_subpage_clear_##name(fs_info, page, start, len); \ >> +} \ >> +static inline bool btrfs_page_test_##name(struct btrfs_fs_info >> *fs_info, \ >> + struct page *page, u64 start, u32 len) \ >> +{ \ >> + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) \ >> + return test_page_func(page); \ >> + return btrfs_subpage_test_##name(fs_info, page, start, len); \ >> +} > > Another thing I just realized is you're doing this > > btrfs_page_set_uptodate(fs_info, page, eb->start, eb->len); > > but we default to a nodesize > PAGE_SIZE on x86. This is fine, because > you're checking fs_info->sectorsize == PAGE_SIZE, which will mean we do > the right thing. > > But what happens if fs_info->nodesize < PAGE_SIZE && fs_info->sectorsize > == PAGE_SIZE? We by default have fs'es that ->nodesize != ->sectorsize, > so really what we should be doing is checking if len == PAGE_SIZE here, > but then you need to take into account the case that eb->len > > PAGE_SIZE. Fix this to do the right thing in either of those cases. > Thanks, Impossible. Nodesize must be >= sectorsize. As sectorsize is currently the minimal access unit for both data and metadata. Thanks, Qu > > Josef
On 1/20/21 7:49 PM, Qu Wenruo wrote: > > > On 2021/1/20 下午11:00, Josef Bacik wrote: >> On 1/16/21 2:15 AM, Qu Wenruo wrote: >>> This patch introduce the following functions to handle btrfs subpage >>> uptodate status: >>> - btrfs_subpage_set_uptodate() >>> - btrfs_subpage_clear_uptodate() >>> - btrfs_subpage_test_uptodate() >>> Those helpers can only be called when the range is ensured to be >>> inside the page. >>> >>> - btrfs_page_set_uptodate() >>> - btrfs_page_clear_uptodate() >>> - btrfs_page_test_uptodate() >>> Those helpers can handle both regular sector size and subpage without >>> problem. >>> Although caller should still ensure that the range is inside the page. >>> >>> Signed-off-by: Qu Wenruo <wqu@suse.com> >>> --- >>> fs/btrfs/subpage.h | 115 +++++++++++++++++++++++++++++++++++++++++++++ >>> 1 file changed, 115 insertions(+) >>> >>> diff --git a/fs/btrfs/subpage.h b/fs/btrfs/subpage.h >>> index d8b34879368d..3373ef4ffec1 100644 >>> --- a/fs/btrfs/subpage.h >>> +++ b/fs/btrfs/subpage.h >>> @@ -23,6 +23,7 @@ >>> struct btrfs_subpage { >>> /* Common members for both data and metadata pages */ >>> spinlock_t lock; >>> + u16 uptodate_bitmap; >>> union { >>> /* Structures only used by metadata */ >>> bool under_alloc; >>> @@ -78,4 +79,118 @@ static inline void btrfs_page_end_meta_alloc(struct >>> btrfs_fs_info *fs_info, >>> int btrfs_attach_subpage(struct btrfs_fs_info *fs_info, struct page *page); >>> void btrfs_detach_subpage(struct btrfs_fs_info *fs_info, struct page *page); >>> +/* >>> + * Convert the [start, start + len) range into a u16 bitmap >>> + * >>> + * E.g. if start == page_offset() + 16K, len = 16K, we get 0x00f0. >>> + */ >>> +static inline u16 btrfs_subpage_calc_bitmap(struct btrfs_fs_info *fs_info, >>> + struct page *page, u64 start, u32 len) >>> +{ >>> + int bit_start = offset_in_page(start) >> fs_info->sectorsize_bits; >>> + int nbits = len >> fs_info->sectorsize_bits; >>> + >>> + /* Basic checks */ >>> + ASSERT(PagePrivate(page) && page->private); >>> + ASSERT(IS_ALIGNED(start, fs_info->sectorsize) && >>> + IS_ALIGNED(len, fs_info->sectorsize)); >>> + >>> + /* >>> + * The range check only works for mapped page, we can >>> + * still have unampped page like dummy extent buffer pages. >>> + */ >>> + if (page->mapping) >>> + ASSERT(page_offset(page) <= start && >>> + start + len <= page_offset(page) + PAGE_SIZE); >>> + /* >>> + * Here nbits can be 16, thus can go beyond u16 range. Here we make the >>> + * first left shift to be calculated in unsigned long (u32), then >>> + * truncate the result to u16. >>> + */ >>> + return (u16)(((1UL << nbits) - 1) << bit_start); >>> +} >>> + >>> +static inline void btrfs_subpage_set_uptodate(struct btrfs_fs_info *fs_info, >>> + struct page *page, u64 start, u32 len) >>> +{ >>> + struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; >>> + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); >>> + unsigned long flags; >>> + >>> + spin_lock_irqsave(&subpage->lock, flags); >>> + subpage->uptodate_bitmap |= tmp; >>> + if (subpage->uptodate_bitmap == U16_MAX) >>> + SetPageUptodate(page); >>> + spin_unlock_irqrestore(&subpage->lock, flags); >>> +} >>> + >>> +static inline void btrfs_subpage_clear_uptodate(struct btrfs_fs_info *fs_info, >>> + struct page *page, u64 start, u32 len) >>> +{ >>> + struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; >>> + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); >>> + unsigned long flags; >>> + >>> + spin_lock_irqsave(&subpage->lock, flags); >>> + subpage->uptodate_bitmap &= ~tmp; >>> + ClearPageUptodate(page); >>> + spin_unlock_irqrestore(&subpage->lock, flags); >>> +} >>> + >>> +/* >>> + * Unlike set/clear which is dependent on each page status, for test all bits >>> + * are tested in the same way. >>> + */ >>> +#define DECLARE_BTRFS_SUBPAGE_TEST_OP(name) \ >>> +static inline bool btrfs_subpage_test_##name(struct btrfs_fs_info *fs_info, \ >>> + struct page *page, u64 start, u32 len) \ >>> +{ \ >>> + struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; \ >>> + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); \ >>> + unsigned long flags; \ >>> + bool ret; \ >>> + \ >>> + spin_lock_irqsave(&subpage->lock, flags); \ >>> + ret = ((subpage->name##_bitmap & tmp) == tmp); \ >>> + spin_unlock_irqrestore(&subpage->lock, flags); \ >>> + return ret; \ >>> +} >>> +DECLARE_BTRFS_SUBPAGE_TEST_OP(uptodate); >>> + >>> +/* >>> + * Note that, in selftest, especially extent-io-tests, we can have empty >>> + * fs_info passed in. >>> + * Thankfully in selftest, we only test sectorsize == PAGE_SIZE cases so far, >>> + * thus we can fall back to regular sectorsize branch. >>> + */ >>> +#define DECLARE_BTRFS_PAGE_OPS(name, set_page_func, clear_page_func, \ >>> + test_page_func) \ >>> +static inline void btrfs_page_set_##name(struct btrfs_fs_info *fs_info, \ >>> + struct page *page, u64 start, u32 len) \ >>> +{ \ >>> + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \ >>> + set_page_func(page); \ >>> + return; \ >>> + } \ >>> + btrfs_subpage_set_##name(fs_info, page, start, len); \ >>> +} \ >>> +static inline void btrfs_page_clear_##name(struct btrfs_fs_info *fs_info, \ >>> + struct page *page, u64 start, u32 len) \ >>> +{ \ >>> + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \ >>> + clear_page_func(page); \ >>> + return; \ >>> + } \ >>> + btrfs_subpage_clear_##name(fs_info, page, start, len); \ >>> +} \ >>> +static inline bool btrfs_page_test_##name(struct btrfs_fs_info *fs_info, \ >>> + struct page *page, u64 start, u32 len) \ >>> +{ \ >>> + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) \ >>> + return test_page_func(page); \ >>> + return btrfs_subpage_test_##name(fs_info, page, start, len); \ >>> +} >> >> Another thing I just realized is you're doing this >> >> btrfs_page_set_uptodate(fs_info, page, eb->start, eb->len); >> >> but we default to a nodesize > PAGE_SIZE on x86. This is fine, because you're >> checking fs_info->sectorsize == PAGE_SIZE, which will mean we do the right thing. >> >> But what happens if fs_info->nodesize < PAGE_SIZE && fs_info->sectorsize == >> PAGE_SIZE? We by default have fs'es that ->nodesize != ->sectorsize, so >> really what we should be doing is checking if len == PAGE_SIZE here, but then >> you need to take into account the case that eb->len > PAGE_SIZE. Fix this to >> do the right thing in either of those cases. Thanks, > > Impossible. > > Nodesize must be >= sectorsize. > > As sectorsize is currently the minimal access unit for both data and metadata. > Ok the consider the alternative, we have PAGE_SIZE == 64k, nodesize == 64k and sectorsize == 4k, something that's actually allowed. You're now doing the subpage operations on something that won't/shouldn't have the subpage private attached to the page. We need to key off of the right thing, so for metadata we need to check ->nodesize, and data we check ->sectorsize, and for these accessors you can simply do len >= PAGE_SIZE. Thanks, Josef
On 2021/1/21 上午9:28, Josef Bacik wrote: > On 1/20/21 7:49 PM, Qu Wenruo wrote: >> >> >> On 2021/1/20 下午11:00, Josef Bacik wrote: >>> On 1/16/21 2:15 AM, Qu Wenruo wrote: >>>> This patch introduce the following functions to handle btrfs subpage >>>> uptodate status: >>>> - btrfs_subpage_set_uptodate() >>>> - btrfs_subpage_clear_uptodate() >>>> - btrfs_subpage_test_uptodate() >>>> Those helpers can only be called when the range is ensured to be >>>> inside the page. >>>> >>>> - btrfs_page_set_uptodate() >>>> - btrfs_page_clear_uptodate() >>>> - btrfs_page_test_uptodate() >>>> Those helpers can handle both regular sector size and subpage >>>> without >>>> problem. >>>> Although caller should still ensure that the range is inside the >>>> page. >>>> >>>> Signed-off-by: Qu Wenruo <wqu@suse.com> >>>> --- >>>> fs/btrfs/subpage.h | 115 >>>> +++++++++++++++++++++++++++++++++++++++++++++ >>>> 1 file changed, 115 insertions(+) >>>> >>>> diff --git a/fs/btrfs/subpage.h b/fs/btrfs/subpage.h >>>> index d8b34879368d..3373ef4ffec1 100644 >>>> --- a/fs/btrfs/subpage.h >>>> +++ b/fs/btrfs/subpage.h >>>> @@ -23,6 +23,7 @@ >>>> struct btrfs_subpage { >>>> /* Common members for both data and metadata pages */ >>>> spinlock_t lock; >>>> + u16 uptodate_bitmap; >>>> union { >>>> /* Structures only used by metadata */ >>>> bool under_alloc; >>>> @@ -78,4 +79,118 @@ static inline void >>>> btrfs_page_end_meta_alloc(struct btrfs_fs_info *fs_info, >>>> int btrfs_attach_subpage(struct btrfs_fs_info *fs_info, struct >>>> page *page); >>>> void btrfs_detach_subpage(struct btrfs_fs_info *fs_info, struct >>>> page *page); >>>> +/* >>>> + * Convert the [start, start + len) range into a u16 bitmap >>>> + * >>>> + * E.g. if start == page_offset() + 16K, len = 16K, we get 0x00f0. >>>> + */ >>>> +static inline u16 btrfs_subpage_calc_bitmap(struct btrfs_fs_info >>>> *fs_info, >>>> + struct page *page, u64 start, u32 len) >>>> +{ >>>> + int bit_start = offset_in_page(start) >> fs_info->sectorsize_bits; >>>> + int nbits = len >> fs_info->sectorsize_bits; >>>> + >>>> + /* Basic checks */ >>>> + ASSERT(PagePrivate(page) && page->private); >>>> + ASSERT(IS_ALIGNED(start, fs_info->sectorsize) && >>>> + IS_ALIGNED(len, fs_info->sectorsize)); >>>> + >>>> + /* >>>> + * The range check only works for mapped page, we can >>>> + * still have unampped page like dummy extent buffer pages. >>>> + */ >>>> + if (page->mapping) >>>> + ASSERT(page_offset(page) <= start && >>>> + start + len <= page_offset(page) + PAGE_SIZE); >>>> + /* >>>> + * Here nbits can be 16, thus can go beyond u16 range. Here we >>>> make the >>>> + * first left shift to be calculated in unsigned long (u32), then >>>> + * truncate the result to u16. >>>> + */ >>>> + return (u16)(((1UL << nbits) - 1) << bit_start); >>>> +} >>>> + >>>> +static inline void btrfs_subpage_set_uptodate(struct btrfs_fs_info >>>> *fs_info, >>>> + struct page *page, u64 start, u32 len) >>>> +{ >>>> + struct btrfs_subpage *subpage = (struct btrfs_subpage >>>> *)page->private; >>>> + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); >>>> + unsigned long flags; >>>> + >>>> + spin_lock_irqsave(&subpage->lock, flags); >>>> + subpage->uptodate_bitmap |= tmp; >>>> + if (subpage->uptodate_bitmap == U16_MAX) >>>> + SetPageUptodate(page); >>>> + spin_unlock_irqrestore(&subpage->lock, flags); >>>> +} >>>> + >>>> +static inline void btrfs_subpage_clear_uptodate(struct >>>> btrfs_fs_info *fs_info, >>>> + struct page *page, u64 start, u32 len) >>>> +{ >>>> + struct btrfs_subpage *subpage = (struct btrfs_subpage >>>> *)page->private; >>>> + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); >>>> + unsigned long flags; >>>> + >>>> + spin_lock_irqsave(&subpage->lock, flags); >>>> + subpage->uptodate_bitmap &= ~tmp; >>>> + ClearPageUptodate(page); >>>> + spin_unlock_irqrestore(&subpage->lock, flags); >>>> +} >>>> + >>>> +/* >>>> + * Unlike set/clear which is dependent on each page status, for >>>> test all bits >>>> + * are tested in the same way. >>>> + */ >>>> +#define DECLARE_BTRFS_SUBPAGE_TEST_OP(name) \ >>>> +static inline bool btrfs_subpage_test_##name(struct btrfs_fs_info >>>> *fs_info, \ >>>> + struct page *page, u64 start, u32 len) \ >>>> +{ \ >>>> + struct btrfs_subpage *subpage = (struct btrfs_subpage >>>> *)page->private; \ >>>> + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); \ >>>> + unsigned long flags; \ >>>> + bool ret; \ >>>> + \ >>>> + spin_lock_irqsave(&subpage->lock, flags); \ >>>> + ret = ((subpage->name##_bitmap & tmp) == tmp); \ >>>> + spin_unlock_irqrestore(&subpage->lock, flags); \ >>>> + return ret; \ >>>> +} >>>> +DECLARE_BTRFS_SUBPAGE_TEST_OP(uptodate); >>>> + >>>> +/* >>>> + * Note that, in selftest, especially extent-io-tests, we can have >>>> empty >>>> + * fs_info passed in. >>>> + * Thankfully in selftest, we only test sectorsize == PAGE_SIZE >>>> cases so far, >>>> + * thus we can fall back to regular sectorsize branch. >>>> + */ >>>> +#define DECLARE_BTRFS_PAGE_OPS(name, set_page_func, >>>> clear_page_func, \ >>>> + test_page_func) \ >>>> +static inline void btrfs_page_set_##name(struct btrfs_fs_info >>>> *fs_info, \ >>>> + struct page *page, u64 start, u32 len) \ >>>> +{ \ >>>> + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \ >>>> + set_page_func(page); \ >>>> + return; \ >>>> + } \ >>>> + btrfs_subpage_set_##name(fs_info, page, start, len); \ >>>> +} \ >>>> +static inline void btrfs_page_clear_##name(struct btrfs_fs_info >>>> *fs_info, \ >>>> + struct page *page, u64 start, u32 len) \ >>>> +{ \ >>>> + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \ >>>> + clear_page_func(page); \ >>>> + return; \ >>>> + } \ >>>> + btrfs_subpage_clear_##name(fs_info, page, start, len); \ >>>> +} \ >>>> +static inline bool btrfs_page_test_##name(struct btrfs_fs_info >>>> *fs_info, \ >>>> + struct page *page, u64 start, u32 len) \ >>>> +{ \ >>>> + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) \ >>>> + return test_page_func(page); \ >>>> + return btrfs_subpage_test_##name(fs_info, page, start, len); \ >>>> +} >>> >>> Another thing I just realized is you're doing this >>> >>> btrfs_page_set_uptodate(fs_info, page, eb->start, eb->len); >>> >>> but we default to a nodesize > PAGE_SIZE on x86. This is fine, >>> because you're checking fs_info->sectorsize == PAGE_SIZE, which will >>> mean we do the right thing. >>> >>> But what happens if fs_info->nodesize < PAGE_SIZE && >>> fs_info->sectorsize == PAGE_SIZE? We by default have fs'es that >>> ->nodesize != ->sectorsize, so really what we should be doing is >>> checking if len == PAGE_SIZE here, but then you need to take into >>> account the case that eb->len > PAGE_SIZE. Fix this to do the right >>> thing in either of those cases. Thanks, >> >> Impossible. >> >> Nodesize must be >= sectorsize. >> >> As sectorsize is currently the minimal access unit for both data and >> metadata. >> > > Ok the consider the alternative, we have PAGE_SIZE == 64k, nodesize == > 64k and sectorsize == 4k, something that's actually allowed. You're now > doing the subpage operations on something that won't/shouldn't have the > subpage private attached to the page. We need to key off of the right > thing, so for metadata we need to check ->nodesize, and data we check > ->sectorsize, and for these accessors you can simply do len >= > PAGE_SIZE. Thanks. For nodesize == 64K and sectorsize == 4K, subpage way of handling it still works. eb->len == 64K now, btrfs_page_set_uptodate() for subpage will just mark the full page uptodate. I tend not to make the nodesize == 64K a special case, or the check condition will be a mess. Now we unify the check to just sectorsize == PAGE_SIZE, nothing else to bother. Thanks, Qu > > Josef
On 2021/1/20 下午10:55, Josef Bacik wrote: > On 1/16/21 2:15 AM, Qu Wenruo wrote: >> This patch introduce the following functions to handle btrfs subpage >> uptodate status: >> - btrfs_subpage_set_uptodate() >> - btrfs_subpage_clear_uptodate() >> - btrfs_subpage_test_uptodate() >> Those helpers can only be called when the range is ensured to be >> inside the page. >> >> - btrfs_page_set_uptodate() >> - btrfs_page_clear_uptodate() >> - btrfs_page_test_uptodate() >> Those helpers can handle both regular sector size and subpage without >> problem. >> Although caller should still ensure that the range is inside the page. >> >> Signed-off-by: Qu Wenruo <wqu@suse.com> >> --- >> fs/btrfs/subpage.h | 115 +++++++++++++++++++++++++++++++++++++++++++++ >> 1 file changed, 115 insertions(+) >> >> diff --git a/fs/btrfs/subpage.h b/fs/btrfs/subpage.h >> index d8b34879368d..3373ef4ffec1 100644 >> --- a/fs/btrfs/subpage.h >> +++ b/fs/btrfs/subpage.h >> @@ -23,6 +23,7 @@ >> struct btrfs_subpage { >> /* Common members for both data and metadata pages */ >> spinlock_t lock; >> + u16 uptodate_bitmap; >> union { >> /* Structures only used by metadata */ >> bool under_alloc; >> @@ -78,4 +79,118 @@ static inline void >> btrfs_page_end_meta_alloc(struct btrfs_fs_info *fs_info, >> int btrfs_attach_subpage(struct btrfs_fs_info *fs_info, struct page >> *page); >> void btrfs_detach_subpage(struct btrfs_fs_info *fs_info, struct page >> *page); >> +/* >> + * Convert the [start, start + len) range into a u16 bitmap >> + * >> + * E.g. if start == page_offset() + 16K, len = 16K, we get 0x00f0. >> + */ >> +static inline u16 btrfs_subpage_calc_bitmap(struct btrfs_fs_info >> *fs_info, >> + struct page *page, u64 start, u32 len) >> +{ >> + int bit_start = offset_in_page(start) >> fs_info->sectorsize_bits; >> + int nbits = len >> fs_info->sectorsize_bits; >> + >> + /* Basic checks */ >> + ASSERT(PagePrivate(page) && page->private); >> + ASSERT(IS_ALIGNED(start, fs_info->sectorsize) && >> + IS_ALIGNED(len, fs_info->sectorsize)); >> + >> + /* >> + * The range check only works for mapped page, we can >> + * still have unampped page like dummy extent buffer pages. >> + */ >> + if (page->mapping) >> + ASSERT(page_offset(page) <= start && >> + start + len <= page_offset(page) + PAGE_SIZE); > > Once you gate the helpers on UNMAPPED you'll always have page->mapping > set and you can drop the if statement. Thanks, > I'd say, if we make ASSERT() to really do nothing if CONFIG_BTRFS_ASSERT is not selected, we won't really need to bother then. As in that case, the function will do nothing. For now, it's a mixed bag as we can still have subpage UNMAPPED eb go into such subpage helpers, and doing the UNMAPPED checks in so many helpers itself can be a big load. Thus I prefer to keep the if here. Thanks, Qu > Josef
diff --git a/fs/btrfs/subpage.h b/fs/btrfs/subpage.h index d8b34879368d..3373ef4ffec1 100644 --- a/fs/btrfs/subpage.h +++ b/fs/btrfs/subpage.h @@ -23,6 +23,7 @@ struct btrfs_subpage { /* Common members for both data and metadata pages */ spinlock_t lock; + u16 uptodate_bitmap; union { /* Structures only used by metadata */ bool under_alloc; @@ -78,4 +79,118 @@ static inline void btrfs_page_end_meta_alloc(struct btrfs_fs_info *fs_info, int btrfs_attach_subpage(struct btrfs_fs_info *fs_info, struct page *page); void btrfs_detach_subpage(struct btrfs_fs_info *fs_info, struct page *page); +/* + * Convert the [start, start + len) range into a u16 bitmap + * + * E.g. if start == page_offset() + 16K, len = 16K, we get 0x00f0. + */ +static inline u16 btrfs_subpage_calc_bitmap(struct btrfs_fs_info *fs_info, + struct page *page, u64 start, u32 len) +{ + int bit_start = offset_in_page(start) >> fs_info->sectorsize_bits; + int nbits = len >> fs_info->sectorsize_bits; + + /* Basic checks */ + ASSERT(PagePrivate(page) && page->private); + ASSERT(IS_ALIGNED(start, fs_info->sectorsize) && + IS_ALIGNED(len, fs_info->sectorsize)); + + /* + * The range check only works for mapped page, we can + * still have unampped page like dummy extent buffer pages. + */ + if (page->mapping) + ASSERT(page_offset(page) <= start && + start + len <= page_offset(page) + PAGE_SIZE); + /* + * Here nbits can be 16, thus can go beyond u16 range. Here we make the + * first left shift to be calculated in unsigned long (u32), then + * truncate the result to u16. + */ + return (u16)(((1UL << nbits) - 1) << bit_start); +} + +static inline void btrfs_subpage_set_uptodate(struct btrfs_fs_info *fs_info, + struct page *page, u64 start, u32 len) +{ + struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); + unsigned long flags; + + spin_lock_irqsave(&subpage->lock, flags); + subpage->uptodate_bitmap |= tmp; + if (subpage->uptodate_bitmap == U16_MAX) + SetPageUptodate(page); + spin_unlock_irqrestore(&subpage->lock, flags); +} + +static inline void btrfs_subpage_clear_uptodate(struct btrfs_fs_info *fs_info, + struct page *page, u64 start, u32 len) +{ + struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); + unsigned long flags; + + spin_lock_irqsave(&subpage->lock, flags); + subpage->uptodate_bitmap &= ~tmp; + ClearPageUptodate(page); + spin_unlock_irqrestore(&subpage->lock, flags); +} + +/* + * Unlike set/clear which is dependent on each page status, for test all bits + * are tested in the same way. + */ +#define DECLARE_BTRFS_SUBPAGE_TEST_OP(name) \ +static inline bool btrfs_subpage_test_##name(struct btrfs_fs_info *fs_info, \ + struct page *page, u64 start, u32 len) \ +{ \ + struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; \ + u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); \ + unsigned long flags; \ + bool ret; \ + \ + spin_lock_irqsave(&subpage->lock, flags); \ + ret = ((subpage->name##_bitmap & tmp) == tmp); \ + spin_unlock_irqrestore(&subpage->lock, flags); \ + return ret; \ +} +DECLARE_BTRFS_SUBPAGE_TEST_OP(uptodate); + +/* + * Note that, in selftest, especially extent-io-tests, we can have empty + * fs_info passed in. + * Thankfully in selftest, we only test sectorsize == PAGE_SIZE cases so far, + * thus we can fall back to regular sectorsize branch. + */ +#define DECLARE_BTRFS_PAGE_OPS(name, set_page_func, clear_page_func, \ + test_page_func) \ +static inline void btrfs_page_set_##name(struct btrfs_fs_info *fs_info, \ + struct page *page, u64 start, u32 len) \ +{ \ + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \ + set_page_func(page); \ + return; \ + } \ + btrfs_subpage_set_##name(fs_info, page, start, len); \ +} \ +static inline void btrfs_page_clear_##name(struct btrfs_fs_info *fs_info, \ + struct page *page, u64 start, u32 len) \ +{ \ + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \ + clear_page_func(page); \ + return; \ + } \ + btrfs_subpage_clear_##name(fs_info, page, start, len); \ +} \ +static inline bool btrfs_page_test_##name(struct btrfs_fs_info *fs_info, \ + struct page *page, u64 start, u32 len) \ +{ \ + if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) \ + return test_page_func(page); \ + return btrfs_subpage_test_##name(fs_info, page, start, len); \ +} +DECLARE_BTRFS_PAGE_OPS(uptodate, SetPageUptodate, ClearPageUptodate, + PageUptodate); + #endif /* BTRFS_SUBPAGE_H */
This patch introduce the following functions to handle btrfs subpage uptodate status: - btrfs_subpage_set_uptodate() - btrfs_subpage_clear_uptodate() - btrfs_subpage_test_uptodate() Those helpers can only be called when the range is ensured to be inside the page. - btrfs_page_set_uptodate() - btrfs_page_clear_uptodate() - btrfs_page_test_uptodate() Those helpers can handle both regular sector size and subpage without problem. Although caller should still ensure that the range is inside the page. Signed-off-by: Qu Wenruo <wqu@suse.com> --- fs/btrfs/subpage.h | 115 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 115 insertions(+)