#include <linux/slab.h>

#include "messages.h"

#include "subpage.h"

#include "btrfs_inode.h"

/*

*

* Limitations:

*

* This means a slightly higher tree locking latency.

*/

int btrfs_attach_subpage(const struct btrfs_fs_info *fs_info,

struct folio *folio, enum btrfs_subpage_type type)

{

struct btrfs_subpage *subpage;

/*

* We have cases like a dummy extent buffer page, which is not mapped

* and doesn't need to be locked.

ASSERT(folio_test_locked(folio));

/* Either not subpage, or the folio already has private attached. */

return 0;

if (IS_ERR(subpage))

return PTR_ERR(subpage);

return 0;

}

{

struct btrfs_subpage *subpage;

/* Either not subpage, or the folio already has private attached. */

return;

subpage = folio_detach_private(folio);

}

struct btrfs_subpage *btrfs_alloc_subpage(const struct btrfs_fs_info *fs_info,

{

struct btrfs_subpage *ret;

unsigned int real_size;

real_size = struct_size(ret, bitmaps,

ret = kzalloc(real_size, GFP_NOFS);

if (!ret)

return ERR_PTR(-ENOMEM);

{

struct btrfs_subpage *subpage;

return;

ASSERT(folio_test_private(folio) && folio->mapping);

{

struct btrfs_subpage *subpage;

return;

ASSERT(folio_test_private(folio) && folio->mapping);

*/

if (folio->mapping)

ASSERT(folio_pos(folio) <= start &&

}

#define subpage_calc_start_bit(fs_info, folio, name, start, len) \

({ \

\

btrfs_subpage_assert(fs_info, folio, start, len); \

__start_bit = offset_in_page(start) >> fs_info->sectorsize_bits; \

__start_bit; \

})

if (folio_pos(folio) >= orig_start + orig_len)

*len = 0;

else

orig_start + orig_len) - *start;

}

ASSERT(folio_test_locked(folio));

folio_unlock(folio);

return;

}

struct folio *folio, unsigned long bitmap)

{

struct btrfs_subpage *subpage = folio_get_private(folio);

unsigned long flags;

bool last = false;

int cleared = 0;

int bit;

folio_unlock(folio);

return;

}

}

spin_lock_irqsave(&subpage->lock, flags);

if (test_and_clear_bit(bit + start_bit, subpage->bitmaps))

cleared++;

}

folio_unlock(folio);

}

bitmap_test_range_all_set(subpage->bitmaps, \

bitmap_test_range_all_zero(subpage->bitmaps, \

void btrfs_subpage_set_uptodate(const struct btrfs_fs_info *fs_info,

struct folio *folio, u64 start, u32 len)

spin_lock_irqsave(&subpage->lock, flags);

bitmap_set(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);

folio_mark_uptodate(folio);

spin_unlock_irqrestore(&subpage->lock, flags);

}

spin_lock_irqsave(&subpage->lock, flags);

bitmap_clear(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);

last = true;

spin_unlock_irqrestore(&subpage->lock, flags);

return last;

spin_lock_irqsave(&subpage->lock, flags);

bitmap_clear(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);

ASSERT(folio_test_writeback(folio));

folio_end_writeback(folio);

}

spin_lock_irqsave(&subpage->lock, flags);

bitmap_clear(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);

folio_clear_ordered(folio);

spin_unlock_irqrestore(&subpage->lock, flags);

}

spin_lock_irqsave(&subpage->lock, flags);

bitmap_set(subpage->bitmaps, start_bit, len >> fs_info->sectorsize_bits);

folio_set_checked(folio);

spin_unlock_irqrestore(&subpage->lock, flags);

}

struct folio *folio, u64 start, u32 len) \

{ \

if (unlikely(!fs_info) || \

folio_set_func(folio); \

return; \

} \

struct folio *folio, u64 start, u32 len) \

{ \

if (unlikely(!fs_info) || \

folio_clear_func(folio); \

return; \

} \

struct folio *folio, u64 start, u32 len) \

{ \

if (unlikely(!fs_info) || \

return folio_test_func(folio); \

return btrfs_subpage_test_##name(fs_info, folio, start, len); \

} \

struct folio *folio, u64 start, u32 len) \

{ \

if (unlikely(!fs_info) || \

folio_set_func(folio); \

return; \

} \

struct folio *folio, u64 start, u32 len) \

{ \

if (unlikely(!fs_info) || \

folio_clear_func(folio); \

return; \

} \

struct folio *folio, u64 start, u32 len) \

{ \

if (unlikely(!fs_info) || \

return folio_test_func(folio); \

btrfs_subpage_clamp_range(folio, &start, &len); \

return btrfs_subpage_test_##name(fs_info, folio, start, len); \

}

IMPLEMENT_BTRFS_PAGE_OPS(uptodate, folio_mark_uptodate, folio_clear_uptodate,

folio_test_uptodate);

IMPLEMENT_BTRFS_PAGE_OPS(checked, folio_set_checked, folio_clear_checked,

folio_test_checked);

{ \

\

*dst = bitmap_read(subpage->bitmaps, \

}

#define SUBPAGE_DUMP_BITMAP(fs_info, folio, name, start, len) \

{ \

unsigned long bitmap; \

\

btrfs_warn(fs_info, \

"dumpping bitmap start=%llu len=%u folio=%llu " #name "_bitmap=%*pbl", \

start, len, folio_pos(folio), \

}

/*

if (!IS_ENABLED(CONFIG_BTRFS_ASSERT))

return;

ASSERT(!folio_test_dirty(folio));

return;

}

int ret;

ASSERT(folio_test_locked(folio));

return;

subpage = folio_get_private(folio);

}

bitmap_set(subpage->bitmaps, start_bit, nbits);

ret = atomic_add_return(nbits, &subpage->nr_locked);

spin_unlock_irqrestore(&subpage->lock, flags);

}

void __cold btrfs_subpage_dump_bitmap(const struct btrfs_fs_info *fs_info,

struct folio *folio, u64 start, u32 len)

{

struct btrfs_subpage *subpage;

unsigned long uptodate_bitmap;

unsigned long dirty_bitmap;

unsigned long writeback_bitmap;

unsigned long flags;

ASSERT(folio_test_private(folio) && folio_get_private(folio));

subpage = folio_get_private(folio);

spin_lock_irqsave(&subpage->lock, flags);

spin_unlock_irqrestore(&subpage->lock, flags);

dump_page(folio_page(folio, 0), "btrfs subpage dump");

btrfs_warn(fs_info,

"start=%llu len=%u page=%llu, bitmaps uptodate=%*pbl dirty=%*pbl locked=%*pbl writeback=%*pbl ordered=%*pbl checked=%*pbl",

start, len, folio_pos(folio),

}

void btrfs_get_subpage_dirty_bitmap(struct btrfs_fs_info *fs_info,

unsigned long flags;

ASSERT(folio_test_private(folio) && folio_get_private(folio));

subpage = folio_get_private(folio);

spin_lock_irqsave(&subpage->lock, flags);

spin_unlock_irqrestore(&subpage->lock, flags);

}