1 // SPDX-License-Identifier: GPL-2.0
3 #include <linux/slab.h>
6 #include "btrfs_inode.h"
9 * Subpage (sectorsize < PAGE_SIZE) support overview:
13 * - Only support 64K page size for now
14 * This is to make metadata handling easier, as 64K page would ensure
15 * all nodesize would fit inside one page, thus we don't need to handle
16 * cases where a tree block crosses several pages.
18 * - Only metadata read-write for now
19 * The data read-write part is in development.
21 * - Metadata can't cross 64K page boundary
22 * btrfs-progs and kernel have done that for a while, thus only ancient
23 * filesystems could have such problem. For such case, do a graceful
29 * Metadata read is fully supported.
30 * Meaning when reading one tree block will only trigger the read for the
31 * needed range, other unrelated range in the same page will not be touched.
33 * Metadata write support is partial.
34 * The writeback is still for the full page, but we will only submit
35 * the dirty extent buffers in the page.
37 * This means, if we have a metadata page like this:
41 * |/////////| |///////////|
42 * \- Tree block A \- Tree block B
44 * Even if we just want to writeback tree block A, we will also writeback
45 * tree block B if it's also dirty.
47 * This may cause extra metadata writeback which results more COW.
52 * Both metadata and data will use a new structure, btrfs_subpage, to
53 * record the status of each sector inside a page. This provides the extra
57 * Since we have multiple tree blocks inside one page, we can't rely on page
58 * locking anymore, or we will have greatly reduced concurrency or even
59 * deadlocks (hold one tree lock while trying to lock another tree lock in
62 * Thus for metadata locking, subpage support relies on io_tree locking only.
63 * This means a slightly higher tree locking latency.
66 void btrfs_init_subpage_info(struct btrfs_subpage_info *subpage_info, u32 sectorsize)
71 ASSERT(IS_ALIGNED(PAGE_SIZE, sectorsize));
73 nr_bits = PAGE_SIZE / sectorsize;
74 subpage_info->bitmap_nr_bits = nr_bits;
76 subpage_info->uptodate_offset = cur;
79 subpage_info->error_offset = cur;
82 subpage_info->dirty_offset = cur;
85 subpage_info->writeback_offset = cur;
88 subpage_info->ordered_offset = cur;
91 subpage_info->checked_offset = cur;
94 subpage_info->total_nr_bits = cur;
97 int btrfs_attach_subpage(const struct btrfs_fs_info *fs_info,
98 struct page *page, enum btrfs_subpage_type type)
100 struct btrfs_subpage *subpage;
103 * We have cases like a dummy extent buffer page, which is not mappped
104 * and doesn't need to be locked.
107 ASSERT(PageLocked(page));
109 /* Either not subpage, or the page already has private attached */
110 if (fs_info->sectorsize == PAGE_SIZE || PagePrivate(page))
113 subpage = btrfs_alloc_subpage(fs_info, type);
115 return PTR_ERR(subpage);
117 attach_page_private(page, subpage);
121 void btrfs_detach_subpage(const struct btrfs_fs_info *fs_info,
124 struct btrfs_subpage *subpage;
126 /* Either not subpage, or already detached */
127 if (fs_info->sectorsize == PAGE_SIZE || !PagePrivate(page))
130 subpage = (struct btrfs_subpage *)detach_page_private(page);
132 btrfs_free_subpage(subpage);
135 struct btrfs_subpage *btrfs_alloc_subpage(const struct btrfs_fs_info *fs_info,
136 enum btrfs_subpage_type type)
138 struct btrfs_subpage *ret;
139 unsigned int real_size;
141 ASSERT(fs_info->sectorsize < PAGE_SIZE);
143 real_size = struct_size(ret, bitmaps,
144 BITS_TO_LONGS(fs_info->subpage_info->total_nr_bits));
145 ret = kzalloc(real_size, GFP_NOFS);
147 return ERR_PTR(-ENOMEM);
149 spin_lock_init(&ret->lock);
150 if (type == BTRFS_SUBPAGE_METADATA) {
151 atomic_set(&ret->eb_refs, 0);
153 atomic_set(&ret->readers, 0);
154 atomic_set(&ret->writers, 0);
159 void btrfs_free_subpage(struct btrfs_subpage *subpage)
165 * Increase the eb_refs of current subpage.
167 * This is important for eb allocation, to prevent race with last eb freeing
169 * With the eb_refs increased before the eb inserted into radix tree,
170 * detach_extent_buffer_page() won't detach the page private while we're still
171 * allocating the extent buffer.
173 void btrfs_page_inc_eb_refs(const struct btrfs_fs_info *fs_info,
176 struct btrfs_subpage *subpage;
178 if (fs_info->sectorsize == PAGE_SIZE)
181 ASSERT(PagePrivate(page) && page->mapping);
182 lockdep_assert_held(&page->mapping->private_lock);
184 subpage = (struct btrfs_subpage *)page->private;
185 atomic_inc(&subpage->eb_refs);
188 void btrfs_page_dec_eb_refs(const struct btrfs_fs_info *fs_info,
191 struct btrfs_subpage *subpage;
193 if (fs_info->sectorsize == PAGE_SIZE)
196 ASSERT(PagePrivate(page) && page->mapping);
197 lockdep_assert_held(&page->mapping->private_lock);
199 subpage = (struct btrfs_subpage *)page->private;
200 ASSERT(atomic_read(&subpage->eb_refs));
201 atomic_dec(&subpage->eb_refs);
204 static void btrfs_subpage_assert(const struct btrfs_fs_info *fs_info,
205 struct page *page, u64 start, u32 len)
208 ASSERT(PagePrivate(page) && page->private);
209 ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&
210 IS_ALIGNED(len, fs_info->sectorsize));
212 * The range check only works for mapped page, we can still have
213 * unmapped page like dummy extent buffer pages.
216 ASSERT(page_offset(page) <= start &&
217 start + len <= page_offset(page) + PAGE_SIZE);
220 void btrfs_subpage_start_reader(const struct btrfs_fs_info *fs_info,
221 struct page *page, u64 start, u32 len)
223 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
224 const int nbits = len >> fs_info->sectorsize_bits;
226 btrfs_subpage_assert(fs_info, page, start, len);
228 atomic_add(nbits, &subpage->readers);
231 void btrfs_subpage_end_reader(const struct btrfs_fs_info *fs_info,
232 struct page *page, u64 start, u32 len)
234 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
235 const int nbits = len >> fs_info->sectorsize_bits;
239 btrfs_subpage_assert(fs_info, page, start, len);
240 is_data = is_data_inode(page->mapping->host);
241 ASSERT(atomic_read(&subpage->readers) >= nbits);
242 last = atomic_sub_and_test(nbits, &subpage->readers);
245 * For data we need to unlock the page if the last read has finished.
247 * And please don't replace @last with atomic_sub_and_test() call
248 * inside if () condition.
249 * As we want the atomic_sub_and_test() to be always executed.
255 static void btrfs_subpage_clamp_range(struct page *page, u64 *start, u32 *len)
257 u64 orig_start = *start;
260 *start = max_t(u64, page_offset(page), orig_start);
262 * For certain call sites like btrfs_drop_pages(), we may have pages
263 * beyond the target range. In that case, just set @len to 0, subpage
264 * helpers can handle @len == 0 without any problem.
266 if (page_offset(page) >= orig_start + orig_len)
269 *len = min_t(u64, page_offset(page) + PAGE_SIZE,
270 orig_start + orig_len) - *start;
273 void btrfs_subpage_start_writer(const struct btrfs_fs_info *fs_info,
274 struct page *page, u64 start, u32 len)
276 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
277 const int nbits = (len >> fs_info->sectorsize_bits);
280 btrfs_subpage_assert(fs_info, page, start, len);
282 ASSERT(atomic_read(&subpage->readers) == 0);
283 ret = atomic_add_return(nbits, &subpage->writers);
284 ASSERT(ret == nbits);
287 bool btrfs_subpage_end_and_test_writer(const struct btrfs_fs_info *fs_info,
288 struct page *page, u64 start, u32 len)
290 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
291 const int nbits = (len >> fs_info->sectorsize_bits);
293 btrfs_subpage_assert(fs_info, page, start, len);
296 * We have call sites passing @lock_page into
297 * extent_clear_unlock_delalloc() for compression path.
299 * This @locked_page is locked by plain lock_page(), thus its
300 * subpage::writers is 0. Handle them in a special way.
302 if (atomic_read(&subpage->writers) == 0)
305 ASSERT(atomic_read(&subpage->writers) >= nbits);
306 return atomic_sub_and_test(nbits, &subpage->writers);
310 * Lock a page for delalloc page writeback.
312 * Return -EAGAIN if the page is not properly initialized.
313 * Return 0 with the page locked, and writer counter updated.
315 * Even with 0 returned, the page still need extra check to make sure
316 * it's really the correct page, as the caller is using
317 * find_get_pages_contig(), which can race with page invalidating.
319 int btrfs_page_start_writer_lock(const struct btrfs_fs_info *fs_info,
320 struct page *page, u64 start, u32 len)
322 if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) {
327 if (!PagePrivate(page) || !page->private) {
331 btrfs_subpage_clamp_range(page, &start, &len);
332 btrfs_subpage_start_writer(fs_info, page, start, len);
336 void btrfs_page_end_writer_lock(const struct btrfs_fs_info *fs_info,
337 struct page *page, u64 start, u32 len)
339 if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE)
340 return unlock_page(page);
341 btrfs_subpage_clamp_range(page, &start, &len);
342 if (btrfs_subpage_end_and_test_writer(fs_info, page, start, len))
346 static bool bitmap_test_range_all_set(unsigned long *addr, unsigned int start,
349 unsigned int found_zero;
351 found_zero = find_next_zero_bit(addr, start + nbits, start);
352 if (found_zero == start + nbits)
357 static bool bitmap_test_range_all_zero(unsigned long *addr, unsigned int start,
360 unsigned int found_set;
362 found_set = find_next_bit(addr, start + nbits, start);
363 if (found_set == start + nbits)
368 #define subpage_calc_start_bit(fs_info, page, name, start, len) \
370 unsigned int start_bit; \
372 btrfs_subpage_assert(fs_info, page, start, len); \
373 start_bit = offset_in_page(start) >> fs_info->sectorsize_bits; \
374 start_bit += fs_info->subpage_info->name##_offset; \
378 #define subpage_test_bitmap_all_set(fs_info, subpage, name) \
379 bitmap_test_range_all_set(subpage->bitmaps, \
380 fs_info->subpage_info->name##_offset, \
381 fs_info->subpage_info->bitmap_nr_bits)
383 #define subpage_test_bitmap_all_zero(fs_info, subpage, name) \
384 bitmap_test_range_all_zero(subpage->bitmaps, \
385 fs_info->subpage_info->name##_offset, \
386 fs_info->subpage_info->bitmap_nr_bits)
388 void btrfs_subpage_set_uptodate(const struct btrfs_fs_info *fs_info,
389 struct page *page, u64 start, u32 len)
391 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
392 unsigned int start_bit = subpage_calc_start_bit(fs_info, page,
393 uptodate, start, len);
396 spin_lock_irqsave(&subpage->lock, flags);
397 bitmap_set(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
398 if (subpage_test_bitmap_all_set(fs_info, subpage, uptodate))
399 SetPageUptodate(page);
400 spin_unlock_irqrestore(&subpage->lock, flags);
403 void btrfs_subpage_clear_uptodate(const struct btrfs_fs_info *fs_info,
404 struct page *page, u64 start, u32 len)
406 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
407 unsigned int start_bit = subpage_calc_start_bit(fs_info, page,
408 uptodate, start, len);
411 spin_lock_irqsave(&subpage->lock, flags);
412 bitmap_clear(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
413 ClearPageUptodate(page);
414 spin_unlock_irqrestore(&subpage->lock, flags);
417 void btrfs_subpage_set_error(const struct btrfs_fs_info *fs_info,
418 struct page *page, u64 start, u32 len)
420 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
421 unsigned int start_bit = subpage_calc_start_bit(fs_info, page,
425 spin_lock_irqsave(&subpage->lock, flags);
426 bitmap_set(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
428 spin_unlock_irqrestore(&subpage->lock, flags);
431 void btrfs_subpage_clear_error(const struct btrfs_fs_info *fs_info,
432 struct page *page, u64 start, u32 len)
434 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
435 unsigned int start_bit = subpage_calc_start_bit(fs_info, page,
439 spin_lock_irqsave(&subpage->lock, flags);
440 bitmap_clear(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
441 if (subpage_test_bitmap_all_zero(fs_info, subpage, error))
442 ClearPageError(page);
443 spin_unlock_irqrestore(&subpage->lock, flags);
446 void btrfs_subpage_set_dirty(const struct btrfs_fs_info *fs_info,
447 struct page *page, u64 start, u32 len)
449 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
450 unsigned int start_bit = subpage_calc_start_bit(fs_info, page,
454 spin_lock_irqsave(&subpage->lock, flags);
455 bitmap_set(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
456 spin_unlock_irqrestore(&subpage->lock, flags);
457 set_page_dirty(page);
461 * Extra clear_and_test function for subpage dirty bitmap.
463 * Return true if we're the last bits in the dirty_bitmap and clear the
465 * Return false otherwise.
467 * NOTE: Callers should manually clear page dirty for true case, as we have
468 * extra handling for tree blocks.
470 bool btrfs_subpage_clear_and_test_dirty(const struct btrfs_fs_info *fs_info,
471 struct page *page, u64 start, u32 len)
473 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
474 unsigned int start_bit = subpage_calc_start_bit(fs_info, page,
479 spin_lock_irqsave(&subpage->lock, flags);
480 bitmap_clear(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
481 if (subpage_test_bitmap_all_zero(fs_info, subpage, dirty))
483 spin_unlock_irqrestore(&subpage->lock, flags);
487 void btrfs_subpage_clear_dirty(const struct btrfs_fs_info *fs_info,
488 struct page *page, u64 start, u32 len)
492 last = btrfs_subpage_clear_and_test_dirty(fs_info, page, start, len);
494 clear_page_dirty_for_io(page);
497 void btrfs_subpage_set_writeback(const struct btrfs_fs_info *fs_info,
498 struct page *page, u64 start, u32 len)
500 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
501 unsigned int start_bit = subpage_calc_start_bit(fs_info, page,
502 writeback, start, len);
505 spin_lock_irqsave(&subpage->lock, flags);
506 bitmap_set(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
507 set_page_writeback(page);
508 spin_unlock_irqrestore(&subpage->lock, flags);
511 void btrfs_subpage_clear_writeback(const struct btrfs_fs_info *fs_info,
512 struct page *page, u64 start, u32 len)
514 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
515 unsigned int start_bit = subpage_calc_start_bit(fs_info, page,
516 writeback, start, len);
519 spin_lock_irqsave(&subpage->lock, flags);
520 bitmap_clear(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
521 if (subpage_test_bitmap_all_zero(fs_info, subpage, writeback)) {
522 ASSERT(PageWriteback(page));
523 end_page_writeback(page);
525 spin_unlock_irqrestore(&subpage->lock, flags);
528 void btrfs_subpage_set_ordered(const struct btrfs_fs_info *fs_info,
529 struct page *page, u64 start, u32 len)
531 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
532 unsigned int start_bit = subpage_calc_start_bit(fs_info, page,
533 ordered, start, len);
536 spin_lock_irqsave(&subpage->lock, flags);
537 bitmap_set(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
538 SetPageOrdered(page);
539 spin_unlock_irqrestore(&subpage->lock, flags);
542 void btrfs_subpage_clear_ordered(const struct btrfs_fs_info *fs_info,
543 struct page *page, u64 start, u32 len)
545 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
546 unsigned int start_bit = subpage_calc_start_bit(fs_info, page,
547 ordered, start, len);
550 spin_lock_irqsave(&subpage->lock, flags);
551 bitmap_clear(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
552 if (subpage_test_bitmap_all_zero(fs_info, subpage, ordered))
553 ClearPageOrdered(page);
554 spin_unlock_irqrestore(&subpage->lock, flags);
557 void btrfs_subpage_set_checked(const struct btrfs_fs_info *fs_info,
558 struct page *page, u64 start, u32 len)
560 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
561 unsigned int start_bit = subpage_calc_start_bit(fs_info, page,
562 checked, start, len);
565 spin_lock_irqsave(&subpage->lock, flags);
566 bitmap_set(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
567 if (subpage_test_bitmap_all_set(fs_info, subpage, checked))
568 SetPageChecked(page);
569 spin_unlock_irqrestore(&subpage->lock, flags);
572 void btrfs_subpage_clear_checked(const struct btrfs_fs_info *fs_info,
573 struct page *page, u64 start, u32 len)
575 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
576 unsigned int start_bit = subpage_calc_start_bit(fs_info, page,
577 checked, start, len);
580 spin_lock_irqsave(&subpage->lock, flags);
581 bitmap_clear(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);
582 ClearPageChecked(page);
583 spin_unlock_irqrestore(&subpage->lock, flags);
587 * Unlike set/clear which is dependent on each page status, for test all bits
588 * are tested in the same way.
590 #define IMPLEMENT_BTRFS_SUBPAGE_TEST_OP(name) \
591 bool btrfs_subpage_test_##name(const struct btrfs_fs_info *fs_info, \
592 struct page *page, u64 start, u32 len) \
594 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; \
595 unsigned int start_bit = subpage_calc_start_bit(fs_info, page, \
597 unsigned long flags; \
600 spin_lock_irqsave(&subpage->lock, flags); \
601 ret = bitmap_test_range_all_set(subpage->bitmaps, start_bit, \
602 len >> fs_info->sectorsize_bits); \
603 spin_unlock_irqrestore(&subpage->lock, flags); \
606 IMPLEMENT_BTRFS_SUBPAGE_TEST_OP(uptodate);
607 IMPLEMENT_BTRFS_SUBPAGE_TEST_OP(error);
608 IMPLEMENT_BTRFS_SUBPAGE_TEST_OP(dirty);
609 IMPLEMENT_BTRFS_SUBPAGE_TEST_OP(writeback);
610 IMPLEMENT_BTRFS_SUBPAGE_TEST_OP(ordered);
611 IMPLEMENT_BTRFS_SUBPAGE_TEST_OP(checked);
614 * Note that, in selftests (extent-io-tests), we can have empty fs_info passed
615 * in. We only test sectorsize == PAGE_SIZE cases so far, thus we can fall
616 * back to regular sectorsize branch.
618 #define IMPLEMENT_BTRFS_PAGE_OPS(name, set_page_func, clear_page_func, \
620 void btrfs_page_set_##name(const struct btrfs_fs_info *fs_info, \
621 struct page *page, u64 start, u32 len) \
623 if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \
624 set_page_func(page); \
627 btrfs_subpage_set_##name(fs_info, page, start, len); \
629 void btrfs_page_clear_##name(const struct btrfs_fs_info *fs_info, \
630 struct page *page, u64 start, u32 len) \
632 if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \
633 clear_page_func(page); \
636 btrfs_subpage_clear_##name(fs_info, page, start, len); \
638 bool btrfs_page_test_##name(const struct btrfs_fs_info *fs_info, \
639 struct page *page, u64 start, u32 len) \
641 if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) \
642 return test_page_func(page); \
643 return btrfs_subpage_test_##name(fs_info, page, start, len); \
645 void btrfs_page_clamp_set_##name(const struct btrfs_fs_info *fs_info, \
646 struct page *page, u64 start, u32 len) \
648 if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \
649 set_page_func(page); \
652 btrfs_subpage_clamp_range(page, &start, &len); \
653 btrfs_subpage_set_##name(fs_info, page, start, len); \
655 void btrfs_page_clamp_clear_##name(const struct btrfs_fs_info *fs_info, \
656 struct page *page, u64 start, u32 len) \
658 if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) { \
659 clear_page_func(page); \
662 btrfs_subpage_clamp_range(page, &start, &len); \
663 btrfs_subpage_clear_##name(fs_info, page, start, len); \
665 bool btrfs_page_clamp_test_##name(const struct btrfs_fs_info *fs_info, \
666 struct page *page, u64 start, u32 len) \
668 if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) \
669 return test_page_func(page); \
670 btrfs_subpage_clamp_range(page, &start, &len); \
671 return btrfs_subpage_test_##name(fs_info, page, start, len); \
673 IMPLEMENT_BTRFS_PAGE_OPS(uptodate, SetPageUptodate, ClearPageUptodate,
675 IMPLEMENT_BTRFS_PAGE_OPS(error, SetPageError, ClearPageError, PageError);
676 IMPLEMENT_BTRFS_PAGE_OPS(dirty, set_page_dirty, clear_page_dirty_for_io,
678 IMPLEMENT_BTRFS_PAGE_OPS(writeback, set_page_writeback, end_page_writeback,
680 IMPLEMENT_BTRFS_PAGE_OPS(ordered, SetPageOrdered, ClearPageOrdered,
682 IMPLEMENT_BTRFS_PAGE_OPS(checked, SetPageChecked, ClearPageChecked, PageChecked);
685 * Make sure not only the page dirty bit is cleared, but also subpage dirty bit
688 void btrfs_page_assert_not_dirty(const struct btrfs_fs_info *fs_info,
691 struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
693 if (!IS_ENABLED(CONFIG_BTRFS_ASSERT))
696 ASSERT(!PageDirty(page));
697 if (fs_info->sectorsize == PAGE_SIZE)
700 ASSERT(PagePrivate(page) && page->private);
701 ASSERT(subpage_test_bitmap_all_zero(fs_info, subpage, dirty));
705 * Handle different locked pages with different page sizes:
707 * - Page locked by plain lock_page()
708 * It should not have any subpage::writers count.
709 * Can be unlocked by unlock_page().
710 * This is the most common locked page for __extent_writepage() called
711 * inside extent_write_cache_pages() or extent_write_full_page().
712 * Rarer cases include the @locked_page from extent_write_locked_range().
714 * - Page locked by lock_delalloc_pages()
715 * There is only one caller, all pages except @locked_page for
716 * extent_write_locked_range().
717 * In this case, we have to call subpage helper to handle the case.
719 void btrfs_page_unlock_writer(struct btrfs_fs_info *fs_info, struct page *page,
722 struct btrfs_subpage *subpage;
724 ASSERT(PageLocked(page));
725 /* For regular page size case, we just unlock the page */
726 if (fs_info->sectorsize == PAGE_SIZE)
727 return unlock_page(page);
729 ASSERT(PagePrivate(page) && page->private);
730 subpage = (struct btrfs_subpage *)page->private;
733 * For subpage case, there are two types of locked page. With or
734 * without writers number.
736 * Since we own the page lock, no one else could touch subpage::writers
737 * and we are safe to do several atomic operations without spinlock.
739 if (atomic_read(&subpage->writers) == 0)
740 /* No writers, locked by plain lock_page() */
741 return unlock_page(page);
743 /* Have writers, use proper subpage helper to end it */
744 btrfs_page_end_writer_lock(fs_info, page, start, len);