arch/s390/hypfs/inode.c

104

struct hypfs_sb_info *fs_info;

arch/s390/hypfs/inode.c

115

fs_info = inode->i_sb->s_fs_info;

arch/s390/hypfs/inode.c

117

mutex_lock(&fs_info->lock);

arch/s390/hypfs/inode.c

120

mutex_unlock(&fs_info->lock);

arch/s390/hypfs/inode.c

123

mutex_unlock(&fs_info->lock);

arch/s390/hypfs/inode.c

152

struct hypfs_sb_info *fs_info = sb->s_fs_info;

arch/s390/hypfs/inode.c

165

mutex_lock(&fs_info->lock);

arch/s390/hypfs/inode.c

166

if (fs_info->last_update == ktime_get_seconds()) {

arch/s390/hypfs/inode.c

184

mutex_unlock(&fs_info->lock);

drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c

2272

struct ras_fs_if fs_info;

drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c

2286

snprintf(fs_info.debugfs_name, sizeof(fs_info.debugfs_name),

drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c

2289

fs_info.head = obj->head;

drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c

2290

amdgpu_ras_debugfs_create(adev, &fs_info, dir);

fs/btrfs/accessors.c

17

btrfs_warn(eb->fs_info,

fs/btrfs/accessors.h

111

WARN_ON(!IS_ALIGNED(val, eb->fs_info->sectorsize));

fs/btrfs/async-thread.c

124

struct btrfs_fs_info *fs_info, const char *name,

fs/btrfs/async-thread.c

133

btrfs_init_workqueue(ret, fs_info);

fs/btrfs/async-thread.c

27

struct btrfs_fs_info *fs_info;

fs/btrfs/async-thread.c

280

trace_btrfs_all_work_done(wq->fs_info, work);

fs/btrfs/async-thread.c

288

trace_btrfs_all_work_done(wq->fs_info, self);

fs/btrfs/async-thread.c

325

trace_btrfs_all_work_done(wq->fs_info, work);

fs/btrfs/async-thread.c

52

return wq->fs_info;

fs/btrfs/async-thread.c

57

return work->wq->fs_info;

fs/btrfs/async-thread.c

75

struct btrfs_fs_info *fs_info)

fs/btrfs/async-thread.c

77

wq->fs_info = fs_info;

fs/btrfs/async-thread.c

84

struct btrfs_workqueue *btrfs_alloc_workqueue(struct btrfs_fs_info *fs_info,

fs/btrfs/async-thread.c

93

btrfs_init_workqueue(ret, fs_info);

fs/btrfs/async-thread.h

32

struct btrfs_workqueue *btrfs_alloc_workqueue(struct btrfs_fs_info *fs_info,

fs/btrfs/async-thread.h

38

struct btrfs_fs_info *fs_info, const char *name,

fs/btrfs/backref.c

1066

ret = add_direct_ref(ctx->fs_info, preftrees,

fs/btrfs/backref.c

1077

ret = add_direct_ref(ctx->fs_info, preftrees, 0, offset,

fs/btrfs/backref.c

1082

ret = add_indirect_ref(ctx->fs_info, preftrees, offset,

fs/btrfs/backref.c

1109

ret = add_indirect_ref(ctx->fs_info, preftrees,

fs/btrfs/backref.c

1115

ASSERT(btrfs_fs_incompat(ctx->fs_info, SIMPLE_QUOTA));

fs/btrfs/backref.c

1139

struct btrfs_fs_info *fs_info = extent_root->fs_info;

fs/btrfs/backref.c

1168

ret = add_direct_ref(fs_info, preftrees,

fs/btrfs/backref.c

1180

ret = add_direct_ref(fs_info, preftrees, 0,

fs/btrfs/backref.c

1187

ret = add_indirect_ref(fs_info, preftrees, key.offset,

fs/btrfs/backref.c

1216

ret = add_indirect_ref(fs_info, preftrees, root,

fs/btrfs/backref.c

1241

const struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/backref.c

1245

lockdep_assert_held(&fs_info->commit_root_sem);

fs/btrfs/backref.c

1281

entry->gen != btrfs_get_last_root_drop_gen(fs_info))

fs/btrfs/backref.c

1311

const struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/backref.c

1316

lockdep_assert_held(&fs_info->commit_root_sem);

fs/btrfs/backref.c

1333

gen = btrfs_get_last_root_drop_gen(fs_info);

fs/btrfs/backref.c

1375

struct btrfs_root *root = btrfs_extent_root(ctx->fs_info, ctx->bytenr);

fs/btrfs/backref.c

1392

btrfs_err(ctx->fs_info,

fs/btrfs/backref.c

1403

if (btrfs_fs_incompat(ctx->fs_info, SKINNY_METADATA))

fs/btrfs/backref.c

1445

head = btrfs_find_delayed_ref_head(ctx->fs_info, delayed_refs,

fs/btrfs/backref.c

1464

ret = add_delayed_refs(ctx->fs_info, head, ctx->time_seq,

fs/btrfs/backref.c

1565

ret = add_missing_keys(ctx->fs_info, &preftrees, !path->skip_locking);

fs/btrfs/backref.c

1612

eb = read_tree_block(ctx->fs_info, ref->parent,

fs/btrfs/backref.c

1794

down_read(&ctx->fs_info->commit_root_sem);

fs/btrfs/backref.c

1797

up_read(&ctx->fs_info->commit_root_sem);

fs/btrfs/backref.c

1849

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/backref.c

1883

down_read(&fs_info->commit_root_sem);

fs/btrfs/backref.c

1885

btrfs_get_tree_mod_seq(fs_info, &elem);

fs/btrfs/backref.c

1908

walk_ctx.fs_info = fs_info;

fs/btrfs/backref.c

2027

btrfs_put_tree_mod_seq(fs_info, &elem);

fs/btrfs/backref.c

2030

up_read(&fs_info->commit_root_sem);

fs/btrfs/backref.c

2192

int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,

fs/btrfs/backref.c

2196

struct btrfs_root *extent_root = btrfs_extent_root(fs_info, logical);

fs/btrfs/backref.c

2205

btrfs_err(fs_info,

fs/btrfs/backref.c

2212

if (btrfs_fs_incompat(fs_info, SKINNY_METADATA))

fs/btrfs/backref.c

2237

size = fs_info->nodesize;

fs/btrfs/backref.c

2243

btrfs_debug(fs_info,

fs/btrfs/backref.c

2253

btrfs_debug(fs_info,

fs/btrfs/backref.c

2380

static int iterate_leaf_refs(struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

2389

btrfs_debug(fs_info,

fs/btrfs/backref.c

2395

btrfs_debug(fs_info,

fs/btrfs/backref.c

2420

btrfs_debug(ctx->fs_info, "resolving all inodes for extent %llu",

fs/btrfs/backref.c

2429

trans = btrfs_attach_transaction(ctx->fs_info->tree_root);

fs/btrfs/backref.c

2440

btrfs_get_tree_mod_seq(ctx->fs_info, &seq_elem);

fs/btrfs/backref.c

2443

down_read(&ctx->fs_info->commit_root_sem);

fs/btrfs/backref.c

2470

ret = iterate_leaf_refs(ctx->fs_info,

fs/btrfs/backref.c

2501

btrfs_debug(ctx->fs_info,

fs/btrfs/backref.c

2505

ret = iterate_leaf_refs(ctx->fs_info, inode_list,

fs/btrfs/backref.c

2515

btrfs_put_tree_mod_seq(ctx->fs_info, &seq_elem);

fs/btrfs/backref.c

2519

up_read(&ctx->fs_info->commit_root_sem);

fs/btrfs/backref.c

2551

int iterate_inodes_from_logical(u64 logical, struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

2564

ret = extent_from_logical(fs_info, logical, path, &found_key, &flags);

fs/btrfs/backref.c

2576

walk_ctx.fs_info = fs_info;

fs/btrfs/backref.c

2626

btrfs_debug(fs_root->fs_info,

fs/btrfs/backref.c

2840

int btrfs_backref_iter_start(struct btrfs_fs_info *fs_info, struct btrfs_backref_iter *iter, u64 bytenr)

fs/btrfs/backref.c

2842

struct btrfs_root *extent_root = btrfs_extent_root(fs_info, bytenr);

fs/btrfs/backref.c

2849

btrfs_err(fs_info,

fs/btrfs/backref.c

290

static void prelim_ref_insert(const struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

2956

int btrfs_backref_iter_next(struct btrfs_fs_info *fs_info, struct btrfs_backref_iter *iter)

fs/btrfs/backref.c

2992

extent_root = btrfs_extent_root(fs_info, iter->bytenr);

fs/btrfs/backref.c

2994

btrfs_err(fs_info, "missing extent root for extent at bytenr %llu",

fs/btrfs/backref.c

3016

void btrfs_backref_init_cache(struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

3026

cache->fs_info = fs_info;

fs/btrfs/backref.c

312

trace_btrfs_prelim_ref_merge(fs_info, ref, newref,

fs/btrfs/backref.c

3208

root = find_reloc_root(cache->fs_info, cur->bytenr);

fs/btrfs/backref.c

3271

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/backref.c

328

trace_btrfs_prelim_ref_insert(fs_info, newref, NULL, preftree->count);

fs/btrfs/backref.c

3282

root = btrfs_get_fs_root(fs_info, ref_key->offset, false);

fs/btrfs/backref.c

3333

btrfs_err(fs_info,

fs/btrfs/backref.c

3457

ret = btrfs_backref_iter_start(trans->fs_info, iter, cur->bytenr);

fs/btrfs/backref.c

3465

ret = btrfs_backref_iter_next(trans->fs_info, iter);

fs/btrfs/backref.c

3495

for (; ret == 0; ret = btrfs_backref_iter_next(trans->fs_info, iter)) {

fs/btrfs/backref.c

3580

btrfs_backref_panic(cache->fs_info, start->bytenr, -EEXIST);

fs/btrfs/backref.c

3631

btrfs_backref_panic(cache->fs_info, upper->bytenr, -EEXIST);

fs/btrfs/backref.c

387

static int add_prelim_ref(const struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

413

prelim_ref_insert(fs_info, preftree, ref, sc);

fs/btrfs/backref.c

418

static int add_direct_ref(const struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

423

return add_prelim_ref(fs_info, &preftrees->direct, 0, NULL, level,

fs/btrfs/backref.c

428

static int add_indirect_ref(const struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

438

return add_prelim_ref(fs_info, tree, root_id, key, level, 0,

fs/btrfs/backref.c

611

root = btrfs_get_fs_root_commit_root(ctx->fs_info, path, ref->root_id);

fs/btrfs/backref.c

613

root = btrfs_get_fs_root(ctx->fs_info, ref->root_id, false);

fs/btrfs/backref.c

625

if (btrfs_is_testing(ctx->fs_info)) {

fs/btrfs/backref.c

668

btrfs_debug(ctx->fs_info,

fs/btrfs/backref.c

781

prelim_ref_insert(ctx->fs_info, &preftrees->direct, ref,

fs/btrfs/backref.c

810

prelim_ref_insert(ctx->fs_info, &preftrees->direct,

fs/btrfs/backref.c

818

prelim_ref_insert(ctx->fs_info, &preftrees->direct, ref, NULL);

fs/btrfs/backref.c

835

static int add_missing_keys(struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

856

eb = read_tree_block(fs_info, ref->wanted_disk_byte, &check);

fs/btrfs/backref.c

871

prelim_ref_insert(fs_info, &preftrees->indirect, ref, NULL);

fs/btrfs/backref.c

881

static int add_delayed_refs(const struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

924

ret = add_indirect_ref(fs_info, preftrees, node->ref_root,

fs/btrfs/backref.c

937

ret = add_direct_ref(fs_info, preftrees, level + 1,

fs/btrfs/backref.c

966

ret = add_indirect_ref(fs_info, preftrees, node->ref_root,

fs/btrfs/backref.c

973

ret = add_direct_ref(fs_info, preftrees, 0, node->parent,

fs/btrfs/backref.h

216

int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,

fs/btrfs/backref.h

228

int iterate_inodes_from_logical(u64 logical, struct btrfs_fs_info *fs_info,

fs/btrfs/backref.h

304

int btrfs_backref_iter_start(struct btrfs_fs_info *fs_info, struct btrfs_backref_iter *iter, u64 bytenr);

fs/btrfs/backref.h

306

int btrfs_backref_iter_next(struct btrfs_fs_info *fs_info, struct btrfs_backref_iter *iter);

fs/btrfs/backref.h

416

struct btrfs_fs_info *fs_info;

fs/btrfs/backref.h

427

void btrfs_backref_init_cache(struct btrfs_fs_info *fs_info,

fs/btrfs/backref.h

448

static inline void btrfs_backref_panic(struct btrfs_fs_info *fs_info,

fs/btrfs/backref.h

451

btrfs_panic(fs_info, error,

fs/btrfs/backref.h

88

struct btrfs_fs_info *fs_info;

fs/btrfs/bio.c

1004

btrfs_bio_counter_dec(fs_info);

fs/btrfs/bio.c

1015

struct btrfs_fs_info *fs_info = bbio->inode->root->fs_info;

fs/btrfs/bio.c

1026

btrfs_bio_counter_inc_blocked(fs_info);

fs/btrfs/bio.c

1027

ret = btrfs_map_repair_block(fs_info, &smap, logical, length, mirror_num);

fs/btrfs/bio.c

1032

ASSERT(smap.dev == fs_info->dev_replace.srcdev);

fs/btrfs/bio.c

1033

smap.dev = fs_info->dev_replace.tgtdev;

fs/btrfs/bio.c

1039

btrfs_bio_counter_dec(fs_info);

fs/btrfs/bio.c

182

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/bio.c

188

const u32 step = min(fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/bio.c

197

ASSERT(repair_bbio->saved_iter.bi_size == fs_info->sectorsize);

fs/btrfs/bio.c

212

btrfs_debug(fs_info, "no mirror left");

fs/btrfs/bio.c

223

btrfs_repair_io_failure(fs_info, btrfs_ino(inode),

fs/btrfs/bio.c

224

repair_bbio->file_offset, fs_info->sectorsize,

fs/btrfs/bio.c

246

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/bio.c

247

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/bio.c

248

const u32 step = min(fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/bio.c

261

btrfs_debug(fs_info, "repair read error: read error at %llu",

fs/btrfs/bio.c

264

num_copies = btrfs_num_copies(fs_info, logical, sectorsize);

fs/btrfs/bio.c

266

btrfs_debug(fs_info, "no copy to repair from");

fs/btrfs/bio.c

298

btrfs_debug(fs_info, "submitting repair read to mirror %d", mirror);

fs/btrfs/bio.c

306

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/bio.c

307

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/bio.c

362

btrfs_warn_rl(dev->fs_info, "bdev %s unexpected block io error: %d",

fs/btrfs/bio.c

374

static struct workqueue_struct *btrfs_end_io_wq(const struct btrfs_fs_info *fs_info,

fs/btrfs/bio.c

378

return fs_info->endio_meta_workers;

fs/btrfs/bio.c

379

return fs_info->endio_workers;

fs/btrfs/bio.c

402

struct btrfs_fs_info *fs_info = bbio->inode->root->fs_info;

fs/btrfs/bio.c

404

btrfs_bio_counter_dec(fs_info);

fs/btrfs/bio.c

410

queue_work(btrfs_end_io_wq(fs_info, bio), &bbio->end_io_work);

fs/btrfs/bio.c

421

btrfs_bio_counter_dec(bioc->fs_info);

fs/btrfs/bio.c

438

btrfs_bio_counter_dec(bioc->fs_info);

fs/btrfs/bio.c

466

queue_work(btrfs_end_io_wq(bbio->inode->root->fs_info, bio), &bbio->end_io_work);

fs/btrfs/bio.c

492

queue_work(btrfs_end_io_wq(bbio->inode->root->fs_info, bio), &bbio->end_io_work);

fs/btrfs/bio.c

514

u64 zone_start = round_down(physical, dev->fs_info->zone_size);

fs/btrfs/bio.c

521

btrfs_debug(dev->fs_info,

fs/btrfs/bio.c

531

if (dev->fs_devices->collect_fs_stats && bio_op(bio) == REQ_OP_READ && dev->fs_info)

fs/btrfs/bio.c

532

percpu_counter_add(&dev->fs_info->stats_read_blocks,

fs/btrfs/bio.c

533

bio->bi_iter.bi_size >> dev->fs_info->sectorsize_bits);

fs/btrfs/bio.c

678

struct btrfs_fs_info *fs_info = bbio->inode->root->fs_info;

fs/btrfs/bio.c

691

if (auto_csum_mode && test_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags))

fs/btrfs/bio.c

702

if ((bbio->bio.bi_opf & REQ_META) && btrfs_is_zoned(fs_info))

fs/btrfs/bio.c

717

struct btrfs_fs_info *fs_info = bbio->inode->root->fs_info;

fs/btrfs/bio.c

730

btrfs_queue_work(fs_info->workers, &async->work);

fs/btrfs/bio.c

736

struct btrfs_fs_info *fs_info = bbio->inode->root->fs_info;

fs/btrfs/bio.c

740

map_length = min(map_length, fs_info->max_zone_append_size);

fs/btrfs/bio.c

741

sector_offset = bio_split_rw_at(&bbio->bio, &fs_info->limits,

fs/btrfs/bio.c

749

return ALIGN_DOWN(sector_offset << SECTOR_SHIFT, fs_info->sectorsize);

fs/btrfs/bio.c

757

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/bio.c

772

btrfs_bio_counter_inc_blocked(fs_info);

fs/btrfs/bio.c

773

ret = btrfs_map_block(fs_info, btrfs_op(bio), logical, &map_length,

fs/btrfs/bio.c

777

btrfs_bio_counter_dec(fs_info);

fs/btrfs/bio.c

798

split = btrfs_split_bio(fs_info, bbio, map_length);

fs/btrfs/bio.c

80

static struct btrfs_bio *btrfs_split_bio(struct btrfs_fs_info *fs_info,

fs/btrfs/bio.c

801

btrfs_bio_counter_dec(fs_info);

fs/btrfs/bio.c

837

!test_bit(BTRFS_FS_STATE_NO_DATA_CSUMS, &fs_info->fs_state) &&

fs/btrfs/bio.c

848

(btrfs_is_zoned(fs_info) && inode->flags & BTRFS_INODE_NODATASUM)) {

fs/btrfs/bio.c

861

btrfs_bio_counter_dec(fs_info);

fs/btrfs/bio.c

883

struct btrfs_fs_info *fs_info = bbio->inode->root->fs_info;

fs/btrfs/bio.c

886

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/bio.c

936

int btrfs_repair_io_failure(struct btrfs_fs_info *fs_info, u64 ino, u64 fileoff,

fs/btrfs/bio.c

948

ASSERT(IS_ALIGNED(logical, fs_info->sectorsize));

fs/btrfs/bio.c

949

ASSERT(IS_ALIGNED(length, fs_info->sectorsize));

fs/btrfs/bio.c

950

ASSERT(IS_ALIGNED(fileoff, fs_info->sectorsize));

fs/btrfs/bio.c

960

if (unlikely(sb_rdonly(fs_info->sb)))

fs/btrfs/bio.c

963

if (btrfs_repair_one_zone(fs_info, logical))

fs/btrfs/bio.c

971

btrfs_bio_counter_inc_blocked(fs_info);

fs/btrfs/bio.c

972

ret = btrfs_map_repair_block(fs_info, &smap, logical, length, mirror_num);

fs/btrfs/bio.c

997

btrfs_info_rl(fs_info,

fs/btrfs/bio.h

129

int btrfs_repair_io_failure(struct btrfs_fs_info *fs_info, u64 ino, u64 fileoff,

fs/btrfs/block-group.c

1010

write_lock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

1012

list_add_tail(&caching_ctl->list, &fs_info->caching_block_groups);

fs/btrfs/block-group.c

1013

write_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

1017

btrfs_queue_work(fs_info->caching_workers, &caching_ctl->work);

fs/btrfs/block-group.c

1027

static void clear_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)

fs/btrfs/block-group.c

1032

write_seqlock(&fs_info->profiles_lock);

fs/btrfs/block-group.c

1034

fs_info->avail_data_alloc_bits &= ~extra_flags;

fs/btrfs/block-group.c

1036

fs_info->avail_metadata_alloc_bits &= ~extra_flags;

fs/btrfs/block-group.c

1038

fs_info->avail_system_alloc_bits &= ~extra_flags;

fs/btrfs/block-group.c

1039

write_sequnlock(&fs_info->profiles_lock);

fs/btrfs/block-group.c

1050

static void clear_incompat_bg_bits(struct btrfs_fs_info *fs_info, u64 flags)

fs/btrfs/block-group.c

1058

struct list_head *head = &fs_info->space_info;

fs/btrfs/block-group.c

1074

btrfs_clear_fs_incompat(fs_info, RAID56);

fs/btrfs/block-group.c

1076

btrfs_clear_fs_incompat(fs_info, RAID1C34);

fs/btrfs/block-group.c

1080

static struct btrfs_root *btrfs_block_group_root(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

1082

if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE))

fs/btrfs/block-group.c

1083

return fs_info->block_group_root;

fs/btrfs/block-group.c

1084

return btrfs_extent_root(fs_info, 0);

fs/btrfs/block-group.c

1091

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

1096

root = btrfs_block_group_root(fs_info);

fs/btrfs/block-group.c

1098

btrfs_err(fs_info, "missing block group root");

fs/btrfs/block-group.c

1120

if (btrfs_test_opt(bg->fs_info, ENOSPC_DEBUG)) {

fs/btrfs/block-group.c

113

static u64 btrfs_reduce_alloc_profile(struct btrfs_fs_info *fs_info, u64 flags)

fs/btrfs/block-group.c

1136

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

1148

block_group = btrfs_lookup_block_group(fs_info, map->start);

fs/btrfs/block-group.c

115

u64 num_devices = fs_info->fs_devices->rw_devices;

fs/btrfs/block-group.c

1167

btrfs_free_ref_tree_range(fs_info, block_group->start,

fs/btrfs/block-group.c

1173

cluster = &fs_info->data_alloc_cluster;

fs/btrfs/block-group.c

1182

cluster = &fs_info->meta_alloc_cluster;

fs/btrfs/block-group.c

1234

write_lock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

1236

&fs_info->block_group_cache_tree);

fs/btrfs/block-group.c

124

spin_lock(&fs_info->balance_lock);

fs/btrfs/block-group.c

1242

write_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

125

target = get_restripe_target(fs_info, flags);

fs/btrfs/block-group.c

1253

clear_avail_alloc_bits(fs_info, block_group->flags);

fs/btrfs/block-group.c

1256

clear_incompat_bg_bits(fs_info, block_group->flags);

fs/btrfs/block-group.c

1265

write_lock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

127

spin_unlock(&fs_info->balance_lock);

fs/btrfs/block-group.c

1270

list_for_each_entry(ctl, &fs_info->caching_block_groups, list) {

fs/btrfs/block-group.c

1280

write_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

130

spin_unlock(&fs_info->balance_lock);

fs/btrfs/block-group.c

1337

btrfs_warn(fs_info,

fs/btrfs/block-group.c

1373

btrfs_remove_chunk_map(fs_info, map);

fs/btrfs/block-group.c

1379

btrfs_dec_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/block-group.c

1384

struct btrfs_fs_info *fs_info, const u64 chunk_offset)

fs/btrfs/block-group.c

1386

struct btrfs_root *root = btrfs_block_group_root(fs_info);

fs/btrfs/block-group.c

1391

btrfs_err(fs_info, "missing block group root");

fs/btrfs/block-group.c

1395

map = btrfs_find_chunk_map(fs_info, chunk_offset, 1);

fs/btrfs/block-group.c

1487

if (btrfs_is_zoned(cache->fs_info)) {

fs/btrfs/block-group.c

1499

if (ret == -ENOSPC && btrfs_test_opt(cache->fs_info, ENOSPC_DEBUG)) {

fs/btrfs/block-group.c

1500

btrfs_info(cache->fs_info,

fs/btrfs/block-group.c

1510

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

1516

spin_lock(&fs_info->trans_lock);

fs/btrfs/block-group.c

1517

if (!list_is_first(&trans->transaction->list, &fs_info->trans_list)) {

fs/btrfs/block-group.c

1521

spin_unlock(&fs_info->trans_lock);

fs/btrfs/block-group.c

1533

mutex_lock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/block-group.c

1544

mutex_unlock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/block-group.c

1564

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/block-group.c

1567

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1573

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1581

void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

1587

const bool async_trim_enabled = btrfs_test_opt(fs_info, DISCARD_ASYNC);

fs/btrfs/block-group.c

1590

if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags))

fs/btrfs/block-group.c

1593

if (btrfs_fs_closing(fs_info))

fs/btrfs/block-group.c

1600

if (!mutex_trylock(&fs_info->reclaim_bgs_lock))

fs/btrfs/block-group.c

1603

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1604

while (!list_empty(&fs_info->unused_bgs)) {

fs/btrfs/block-group.c

1608

block_group = list_first_entry(&fs_info->unused_bgs,

fs/btrfs/block-group.c

1619

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

162

u64 btrfs_get_alloc_profile(struct btrfs_fs_info *fs_info, u64 orig_flags)

fs/btrfs/block-group.c

1621

btrfs_discard_cancel_work(&fs_info->discard_ctl, block_group);

fs/btrfs/block-group.c

1631

if (btrfs_test_opt(fs_info, DISCARD_ASYNC) &&

fs/btrfs/block-group.c

1636

btrfs_discard_queue_work(&fs_info->discard_ctl,

fs/btrfs/block-group.c

1644

if (btrfs_is_zoned(fs_info) && btrfs_is_block_group_used(block_group) &&

fs/btrfs/block-group.c

169

seq = read_seqbegin(&fs_info->profiles_lock);

fs/btrfs/block-group.c

172

flags |= fs_info->avail_data_alloc_bits;

fs/btrfs/block-group.c

174

flags |= fs_info->avail_system_alloc_bits;

fs/btrfs/block-group.c

1748

trans = btrfs_start_trans_remove_block_group(fs_info,

fs/btrfs/block-group.c

176

flags |= fs_info->avail_metadata_alloc_bits;

fs/btrfs/block-group.c

177

} while (read_seqretry(&fs_info->profiles_lock, seq));

fs/btrfs/block-group.c

1772

spin_lock(&fs_info->discard_ctl.lock);

fs/btrfs/block-group.c

1774

spin_unlock(&fs_info->discard_ctl.lock);

fs/btrfs/block-group.c

1776

btrfs_discard_queue_work(&fs_info->discard_ctl,

fs/btrfs/block-group.c

1780

spin_unlock(&fs_info->discard_ctl.lock);

fs/btrfs/block-group.c

179

return btrfs_reduce_alloc_profile(fs_info, flags);

fs/btrfs/block-group.c

1800

if (!async_trim_enabled && btrfs_test_opt(fs_info, DISCARD_ASYNC))

fs/btrfs/block-group.c

1807

trimming = btrfs_test_opt(fs_info, DISCARD_SYNC) ||

fs/btrfs/block-group.c

1808

btrfs_is_zoned(fs_info);

fs/btrfs/block-group.c

1832

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1840

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1847

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1849

list_splice_tail(&retry_list, &fs_info->unused_bgs);

fs/btrfs/block-group.c

1850

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1851

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/block-group.c

1856

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1857

list_splice_tail(&retry_list, &fs_info->unused_bgs);

fs/btrfs/block-group.c

1858

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1859

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/block-group.c

1861

btrfs_discard_punt_unused_bgs_list(fs_info);

fs/btrfs/block-group.c

1866

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/block-group.c

1868

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1872

list_add_tail(&bg->bg_list, &fs_info->unused_bgs);

fs/btrfs/block-group.c

1879

list_move_tail(&bg->bg_list, &fs_info->unused_bgs);

fs/btrfs/block-group.c

1881

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1906

static inline bool btrfs_should_reclaim(const struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

1908

if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags))

fs/btrfs/block-group.c

1911

if (btrfs_fs_closing(fs_info))

fs/btrfs/block-group.c

1914

if (btrfs_is_zoned(fs_info))

fs/btrfs/block-group.c

1915

return btrfs_zoned_should_reclaim(fs_info);

fs/btrfs/block-group.c

1942

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/block-group.c

1979

if (!btrfs_test_opt(fs_info, DISCARD_ASYNC))

fs/btrfs/block-group.c

199

!BTRFS_FS_LOG_CLEANUP_ERROR(cache->fs_info))

fs/btrfs/block-group.c

2016

if (btrfs_need_cleaner_sleep(fs_info)) {

fs/btrfs/block-group.c

2049

ret = btrfs_relocate_chunk(fs_info, bg->start, false);

fs/btrfs/block-group.c

2052

btrfs_err(fs_info, "error relocating chunk %llu",

fs/btrfs/block-group.c

2073

void btrfs_reclaim_block_groups(struct btrfs_fs_info *fs_info, unsigned int limit)

fs/btrfs/block-group.c

208

btrfs_discard_cancel_work(&cache->fs_info->discard_ctl,

fs/btrfs/block-group.c

2080

if (!btrfs_should_reclaim(fs_info))

fs/btrfs/block-group.c

2083

guard(super_write)(fs_info->sb);

fs/btrfs/block-group.c

2085

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE))

fs/btrfs/block-group.c

2092

if (!mutex_trylock(&fs_info->reclaim_bgs_lock)) {

fs/btrfs/block-group.c

2093

btrfs_exclop_finish(fs_info);

fs/btrfs/block-group.c

2097

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2103

list_sort(NULL, &fs_info->reclaim_bgs, reclaim_bgs_cmp);

fs/btrfs/block-group.c

2104

while (!list_empty(&fs_info->reclaim_bgs)) {

fs/btrfs/block-group.c

2107

bg = list_first_entry(&fs_info->reclaim_bgs,

fs/btrfs/block-group.c

2113

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2120

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/block-group.c

2125

btrfs_delete_unused_bgs(fs_info);

fs/btrfs/block-group.c

2130

if (!mutex_trylock(&fs_info->reclaim_bgs_lock))

fs/btrfs/block-group.c

2132

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2136

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2137

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/block-group.c

2139

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2140

list_splice_tail(&retry_list, &fs_info->reclaim_bgs);

fs/btrfs/block-group.c

2141

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2142

btrfs_exclop_finish(fs_info);

fs/btrfs/block-group.c

2147

struct btrfs_fs_info *fs_info =

fs/btrfs/block-group.c

2150

btrfs_reclaim_block_groups(fs_info, -1);

fs/btrfs/block-group.c

2153

void btrfs_reclaim_bgs(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

2155

btrfs_reclaim_sweep(fs_info);

fs/btrfs/block-group.c

2156

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2157

if (!list_empty(&fs_info->reclaim_bgs))

fs/btrfs/block-group.c

2158

queue_work(system_dfl_wq, &fs_info->reclaim_bgs_work);

fs/btrfs/block-group.c

2159

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2164

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/block-group.c

2166

if (btrfs_link_bg_list(bg, &fs_info->reclaim_bgs))

fs/btrfs/block-group.c

2170

static int read_bg_from_eb(struct btrfs_fs_info *fs_info, const struct btrfs_key *key,

fs/btrfs/block-group.c

2183

map = btrfs_find_chunk_map(fs_info, key->objectid, key->offset);

fs/btrfs/block-group.c

2185

btrfs_err(fs_info,

fs/btrfs/block-group.c

2192

btrfs_err(fs_info,

fs/btrfs/block-group.c

2205

btrfs_err(fs_info,

fs/btrfs/block-group.c

2217

static int find_first_block_group(struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.c

2221

struct btrfs_root *root = btrfs_block_group_root(fs_info);

fs/btrfs/block-group.c

2226

btrfs_err(fs_info, "missing block group root");

fs/btrfs/block-group.c

2233

return read_bg_from_eb(fs_info, &found_key, path);

fs/btrfs/block-group.c

2239

static void set_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)

fs/btrfs/block-group.c

2244

write_seqlock(&fs_info->profiles_lock);

fs/btrfs/block-group.c

2246

fs_info->avail_data_alloc_bits |= extra_flags;

fs/btrfs/block-group.c

2248

fs_info->avail_metadata_alloc_bits |= extra_flags;

fs/btrfs/block-group.c

2250

fs_info->avail_system_alloc_bits |= extra_flags;

fs/btrfs/block-group.c

2251

write_sequnlock(&fs_info->profiles_lock);

fs/btrfs/block-group.c

2268

int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,

fs/btrfs/block-group.c

2279

map = btrfs_get_chunk_map(fs_info, chunk_start, 1);

fs/btrfs/block-group.c

2345

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/block-group.c

2346

const bool zoned = btrfs_is_zoned(fs_info);

fs/btrfs/block-group.c

2355

ret = btrfs_set_extent_bit(&fs_info->excluded_extents, cache->start,

fs/btrfs/block-group.c

2364

ret = btrfs_rmap_block(fs_info, cache->start,

fs/btrfs/block-group.c

237

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

2372

btrfs_err(fs_info,

fs/btrfs/block-group.c

2383

ret = btrfs_set_extent_bit(&fs_info->excluded_extents,

fs/btrfs/block-group.c

2398

struct btrfs_fs_info *fs_info, u64 start)

fs/btrfs/block-group.c

2414

cache->fs_info = fs_info;

fs/btrfs/block-group.c

2415

cache->full_stripe_len = btrfs_full_stripe_len(fs_info, start);

fs/btrfs/block-group.c

243

write_lock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

2441

static int check_chunk_block_group_mappings(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

2451

for (node = rb_first_cached(&fs_info->mapping_tree); node; node = rb_next(node)) {

fs/btrfs/block-group.c

2456

bg = btrfs_lookup_block_group(fs_info, map->start);

fs/btrfs/block-group.c

2458

btrfs_err(fs_info,

fs/btrfs/block-group.c

246

&fs_info->block_group_cache_tree, btrfs_bg_start_cmp);

fs/btrfs/block-group.c

2467

btrfs_err(fs_info,

fs/btrfs/block-group.c

249

write_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

2609

static int fill_dummy_bgs(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

2614

for (node = rb_first_cached(&fs_info->mapping_tree); node; node = rb_next(node)) {

fs/btrfs/block-group.c

2619

bg = btrfs_create_block_group(fs_info, map->start);

fs/btrfs/block-group.c

2631

bg->space_info = btrfs_find_space_info(fs_info, bg->flags);

fs/btrfs/block-group.c

2649

btrfs_add_bg_to_space_info(fs_info, bg);

fs/btrfs/block-group.c

2651

set_avail_alloc_bits(fs_info, bg->flags);

fs/btrfs/block-group.c

2654

btrfs_init_global_block_rsv(fs_info);

fs/btrfs/block-group.c

2788

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

2790

struct btrfs_root *root = btrfs_block_group_root(fs_info);

fs/btrfs/block-group.c

2797

btrfs_err(fs_info, "missing block group root");

fs/btrfs/block-group.c

2817

if (btrfs_fs_incompat(fs_info, REMAP_TREE))

fs/btrfs/block-group.c

2836

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/block-group.c

2837

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/block-group.c

2877

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

2884

map = btrfs_get_chunk_map(fs_info, chunk_offset, chunk_size);

fs/btrfs/block-group.c

2897

mutex_lock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/block-group.c

2907

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/block-group.c

2922

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

2942

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

2944

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

2965

btrfs_dec_delayed_refs_rsv_bg_inserts(fs_info);

fs/btrfs/block-group.c

2967

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2971

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

3011

static u64 calculate_global_root_id(const struct btrfs_fs_info *fs_info, u64 offset)

fs/btrfs/block-group.c

3016

if (!btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))

fs/btrfs/block-group.c

3020

if (btrfs_super_total_bytes(fs_info->super_copy) <= (SZ_1G * 10ULL))

fs/btrfs/block-group.c

3024

div64_u64_rem(offset, fs_info->nr_global_roots, &index);

fs/btrfs/block-group.c

3032

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

3038

cache = btrfs_create_block_group(fs_info, chunk_offset);

fs/btrfs/block-group.c

3053

cache->global_root_id = calculate_global_root_id(fs_info, cache->start);

fs/btrfs/block-group.c

3055

if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE))

fs/btrfs/block-group.c

3098

trace_btrfs_add_block_group(fs_info, cache, 1);

fs/btrfs/block-group.c

3099

btrfs_add_bg_to_space_info(fs_info, cache);

fs/btrfs/block-group.c

3100

btrfs_update_global_block_rsv(fs_info);

fs/btrfs/block-group.c

3110

btrfs_inc_delayed_refs_rsv_bg_inserts(fs_info);

fs/btrfs/block-group.c

3112

set_avail_alloc_bits(fs_info, type);

fs/btrfs/block-group.c

3128

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/block-group.c

3131

struct btrfs_root *root = btrfs_block_group_root(fs_info);

fs/btrfs/block-group.c

3137

btrfs_err(fs_info, "missing block group root");

fs/btrfs/block-group.c

3147

if (sb_rdonly(fs_info->sb)) {

fs/btrfs/block-group.c

3148

mutex_lock(&fs_info->ro_block_group_mutex);

fs/btrfs/block-group.c

3150

mutex_unlock(&fs_info->ro_block_group_mutex);

fs/btrfs/block-group.c

316

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/block-group.c

3166

mutex_lock(&fs_info->ro_block_group_mutex);

fs/btrfs/block-group.c

3170

mutex_unlock(&fs_info->ro_block_group_mutex);

fs/btrfs/block-group.c

3173

ret = btrfs_wait_for_commit(fs_info, transid);

fs/btrfs/block-group.c

3185

alloc_flags = btrfs_get_alloc_profile(fs_info, cache->flags);

fs/btrfs/block-group.c

319

read_lock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

3215

alloc_flags = btrfs_get_alloc_profile(fs_info, space_info->flags);

fs/btrfs/block-group.c

3232

alloc_flags = btrfs_get_alloc_profile(fs_info, cache->flags);

fs/btrfs/block-group.c

3233

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

3235

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

3238

mutex_unlock(&fs_info->ro_block_group_mutex);

fs/btrfs/block-group.c

325

read_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

3253

if (btrfs_is_zoned(cache->fs_info)) {

fs/btrfs/block-group.c

327

return btrfs_lookup_first_block_group(fs_info, next_bytenr);

fs/btrfs/block-group.c

3273

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

3275

struct btrfs_root *root = btrfs_block_group_root(fs_info);

fs/btrfs/block-group.c

3286

btrfs_err(fs_info, "missing block group root");

fs/btrfs/block-group.c

3334

if (btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/block-group.c

336

read_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

3371

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

3380

if (!btrfs_test_opt(fs_info, SPACE_CACHE))

fs/btrfs/block-group.c

3407

btrfs_err(fs_info,

fs/btrfs/block-group.c

3453

ret = btrfs_check_trunc_cache_free_space(fs_info,

fs/btrfs/block-group.c

3454

&fs_info->global_block_rsv);

fs/btrfs/block-group.c

3465

!btrfs_test_opt(fs_info, SPACE_CACHE)) {

fs/btrfs/block-group.c

3496

cache_size *= fs_info->sectorsize;

fs/btrfs/block-group.c

3535

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

3541

!btrfs_test_opt(fs_info, SPACE_CACHE))

fs/btrfs/block-group.c

355

struct btrfs_block_group *btrfs_inc_nocow_writers(struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.c

3572

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

361

bg = btrfs_lookup_block_group(fs_info, bytenr);

fs/btrfs/block-group.c

3691

btrfs_dec_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/block-group.c

3729

btrfs_cleanup_dirty_bgs(cur_trans, fs_info);

fs/btrfs/block-group.c

3737

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

3839

btrfs_dec_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/block-group.c

3870

struct btrfs_fs_info *info = trans->fs_info;

fs/btrfs/block-group.c

4015

trace_btrfs_space_reservation(cache->fs_info, "space_info",

fs/btrfs/block-group.c

406

void btrfs_dec_block_group_reservations(struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.c

4067

else if (btrfs_is_zoned(cache->fs_info))

fs/btrfs/block-group.c

4088

static bool should_alloc_chunk(const struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.c

4102

thresh = btrfs_super_total_bytes(fs_info->super_copy);

fs/btrfs/block-group.c

411

bg = btrfs_lookup_block_group(fs_info, start);

fs/btrfs/block-group.c

4116

u64 alloc_flags = btrfs_get_alloc_profile(trans->fs_info, type);

fs/btrfs/block-group.c

4119

space_info = btrfs_find_space_info(trans->fs_info, type);

fs/btrfs/block-group.c

4189

const u64 sys_flags = btrfs_system_alloc_profile(trans->fs_info);

fs/btrfs/block-group.c

4193

sys_space_info = btrfs_find_space_info(trans->fs_info, sys_flags);

fs/btrfs/block-group.c

4345

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

4388

should_alloc = should_alloc_chunk(fs_info, space_info, force);

fs/btrfs/block-group.c

4410

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4411

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4422

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4437

if (flags & BTRFS_BLOCK_GROUP_DATA && fs_info->metadata_ratio) {

fs/btrfs/block-group.c

4438

fs_info->data_chunk_allocations++;

fs/btrfs/block-group.c

4439

if (!(fs_info->data_chunk_allocations %

fs/btrfs/block-group.c

4440

fs_info->metadata_ratio))

fs/btrfs/block-group.c

4441

force_metadata_allocation(fs_info);

fs/btrfs/block-group.c

4475

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4480

static u64 get_profile_num_devs(const struct btrfs_fs_info *fs_info, u64 type)

fs/btrfs/block-group.c

4486

num_dev = fs_info->fs_devices->rw_devices;

fs/btrfs/block-group.c

4495

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

4504

lockdep_assert_held(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4506

info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);

fs/btrfs/block-group.c

4511

if (left < bytes && btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {

fs/btrfs/block-group.c

4512

btrfs_info(fs_info, "left=%llu, need=%llu, flags=%llu",

fs/btrfs/block-group.c

4518

u64 flags = btrfs_system_alloc_profile(fs_info);

fs/btrfs/block-group.c

4522

space_info = btrfs_find_space_info(fs_info, flags);

fs/btrfs/block-group.c

4562

ret = btrfs_block_rsv_add(fs_info,

fs/btrfs/block-group.c

4563

&fs_info->chunk_block_rsv,

fs/btrfs/block-group.c

4576

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

4577

const u64 num_devs = get_profile_num_devs(fs_info, type);

fs/btrfs/block-group.c

4581

bytes = btrfs_calc_metadata_size(fs_info, num_devs) +

fs/btrfs/block-group.c

4582

btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/block-group.c

4606

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

4610

bytes = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/block-group.c

4612

bytes = btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/block-group.c

4614

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4616

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4645

struct btrfs_fs_info *info = space_info->fs_info;

fs/btrfs/block-group.c

4801

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

4812

map = btrfs_find_chunk_map(fs_info, block_group->start, 1);

fs/btrfs/block-group.c

4816

btrfs_remove_chunk_map(fs_info, map);

fs/btrfs/block-group.c

4917

if (btrfs_is_zoned(bg->fs_info))

fs/btrfs/block-group.c

4927

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

4930

if (btrfs_test_opt(fs_info, DISCARD_ASYNC)) {

fs/btrfs/block-group.c

4935

btrfs_discard_queue_work(&fs_info->discard_ctl, bg);

fs/btrfs/block-group.c

4937

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

4948

list_add_tail(&bg->bg_list, &fs_info->fully_remapped_bgs);

fs/btrfs/block-group.c

4949

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

4963

int btrfs_populate_fully_remapped_bgs_list(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

4967

node_bg = rb_first_cached(&fs_info->block_group_cache_tree);

fs/btrfs/block-group.c

4968

node_chunk = rb_first_cached(&fs_info->mapping_tree);

fs/btrfs/block-group.c

4988

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

4992

list_add_tail(&bg->bg_list, &fs_info->fully_remapped_bgs);

fs/btrfs/block-group.c

4994

list_move_tail(&bg->bg_list, &fs_info->fully_remapped_bgs);

fs/btrfs/block-group.c

4997

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

5008

if (btrfs_test_opt(fs_info, DISCARD_ASYNC)) {

fs/btrfs/block-group.c

527

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

531

fs_info->nodesize : fs_info->sectorsize;

fs/btrfs/block-group.c

56

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

561

struct btrfs_fs_info *info = block_group->fs_info;

fs/btrfs/block-group.c

58

return (btrfs_test_opt(fs_info, FRAGMENT_METADATA) &&

fs/btrfs/block-group.c

60

(btrfs_test_opt(fs_info, FRAGMENT_DATA) &&

fs/btrfs/block-group.c

624

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

635

lockdep_assert_held_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

637

extent_root = btrfs_extent_root(fs_info, block_group->start);

fs/btrfs/block-group.c

639

btrfs_err(fs_info,

fs/btrfs/block-group.c

665

lockdep_assert_held_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

68

if (!btrfs_is_zoned(block_group->fs_info))

fs/btrfs/block-group.c

708

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

729

lockdep_assert_held_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

753

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

768

extent_root = btrfs_extent_root(fs_info, last);

fs/btrfs/block-group.c

770

btrfs_err(fs_info,

fs/btrfs/block-group.c

808

if (btrfs_fs_closing_done(fs_info)) {

fs/btrfs/block-group.c

821

rwsem_is_contended(&fs_info->commit_root_sem)) {

fs/btrfs/block-group.c

823

up_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

827

down_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

84

static u64 get_restripe_target(const struct btrfs_fs_info *fs_info, u64 flags)

fs/btrfs/block-group.c

86

const struct btrfs_balance_control *bctl = fs_info->balance_ctl;

fs/btrfs/block-group.c

868

fs_info->nodesize;

fs/btrfs/block-group.c

888

btrfs_clear_extent_bit(&bg->fs_info->excluded_extents, bg->start,

fs/btrfs/block-group.c

895

struct btrfs_fs_info *fs_info;

fs/btrfs/block-group.c

901

fs_info = block_group->fs_info;

fs/btrfs/block-group.c

904

down_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

907

if (btrfs_test_opt(fs_info, SPACE_CACHE)) {

fs/btrfs/block-group.c

931

if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&

fs/btrfs/block-group.c

932

!(test_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags)))

fs/btrfs/block-group.c

956

up_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

968

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/block-group.c

973

if (btrfs_is_zoned(fs_info))

fs/btrfs/block-group.h

122

struct btrfs_fs_info *fs_info;

fs/btrfs/block-group.h

333

void btrfs_dec_block_group_reservations(struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.h

336

struct btrfs_block_group *btrfs_inc_nocow_writers(struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.h

348

struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.h

353

void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info);

fs/btrfs/block-group.h

355

void btrfs_reclaim_block_groups(struct btrfs_fs_info *fs_info, unsigned int limit);

fs/btrfs/block-group.h

357

void btrfs_reclaim_bgs(struct btrfs_fs_info *fs_info);

fs/btrfs/block-group.h

384

u64 btrfs_get_alloc_profile(struct btrfs_fs_info *fs_info, u64 orig_flags);

fs/btrfs/block-group.h

387

int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,

fs/btrfs/block-group.h

390

static inline u64 btrfs_data_alloc_profile(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.h

392

return btrfs_get_alloc_profile(fs_info, BTRFS_BLOCK_GROUP_DATA);

fs/btrfs/block-group.h

395

static inline u64 btrfs_metadata_alloc_profile(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.h

397

return btrfs_get_alloc_profile(fs_info, BTRFS_BLOCK_GROUP_METADATA);

fs/btrfs/block-group.h

400

static inline u64 btrfs_system_alloc_profile(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.h

402

return btrfs_get_alloc_profile(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);

fs/btrfs/block-group.h

425

int btrfs_populate_fully_remapped_bgs_list(struct btrfs_fs_info *fs_info);

fs/btrfs/block-rsv.c

104

static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.c

181

void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.c

186

rsv->space_info = btrfs_find_space_info(fs_info,

fs/btrfs/block-rsv.c

190

struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.c

199

btrfs_init_metadata_block_rsv(fs_info, block_rsv, type);

fs/btrfs/block-rsv.c

203

void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.c

208

btrfs_block_rsv_release(fs_info, rsv, (u64)-1, NULL);

fs/btrfs/block-rsv.c

212

int btrfs_block_rsv_add(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.c

242

int btrfs_block_rsv_refill(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.c

270

u64 btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.c

274

struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;

fs/btrfs/block-rsv.c

275

struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/block-rsv.c

291

return block_rsv_release_bytes(fs_info, block_rsv, target, num_bytes,

fs/btrfs/block-rsv.c

322

void btrfs_update_global_block_rsv(struct btrfs_fs_info *fs_info)

fs/btrfs/block-rsv.c

324

struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;

fs/btrfs/block-rsv.c

335

if (btrfs_is_full_ro(fs_info)) {

fs/btrfs/block-rsv.c

343

num_bytes = btrfs_root_used(&fs_info->tree_root->root_item);

fs/btrfs/block-rsv.c

353

read_lock(&fs_info->global_root_lock);

fs/btrfs/block-rsv.c

354

rbtree_postorder_for_each_entry_safe(root, tmp, &fs_info->global_root_tree,

fs/btrfs/block-rsv.c

363

read_unlock(&fs_info->global_root_lock);

fs/btrfs/block-rsv.c

365

if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE)) {

fs/btrfs/block-rsv.c

366

num_bytes += btrfs_root_used(&fs_info->block_group_root->root_item);

fs/btrfs/block-rsv.c

370

if (btrfs_fs_incompat(fs_info, RAID_STRIPE_TREE)) {

fs/btrfs/block-rsv.c

371

num_bytes += btrfs_root_used(&fs_info->stripe_root->root_item);

fs/btrfs/block-rsv.c

387

btrfs_calc_insert_metadata_size(fs_info, min_items) +

fs/btrfs/block-rsv.c

388

btrfs_calc_delayed_ref_bytes(fs_info,

fs/btrfs/block-rsv.c

417

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/block-rsv.c

425

root->block_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/block-rsv.c

430

root->block_rsv = &fs_info->global_block_rsv;

fs/btrfs/block-rsv.c

433

root->block_rsv = &fs_info->chunk_block_rsv;

fs/btrfs/block-rsv.c

436

root->block_rsv = &fs_info->treelog_rsv;

fs/btrfs/block-rsv.c

439

root->block_rsv = &fs_info->remap_block_rsv;

fs/btrfs/block-rsv.c

447

void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info)

fs/btrfs/block-rsv.c

451

space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);

fs/btrfs/block-rsv.c

452

fs_info->chunk_block_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

454

space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA_REMAP);

fs/btrfs/block-rsv.c

455

fs_info->remap_block_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

457

space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);

fs/btrfs/block-rsv.c

458

fs_info->global_block_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

459

fs_info->trans_block_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

460

fs_info->empty_block_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

461

fs_info->delayed_block_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

462

fs_info->delayed_refs_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

465

if (!btrfs_is_zoned(fs_info)) {

fs/btrfs/block-rsv.c

466

fs_info->treelog_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

469

fs_info->treelog_rsv.space_info = space_info->sub_group[0];

fs/btrfs/block-rsv.c

472

btrfs_update_global_block_rsv(fs_info);

fs/btrfs/block-rsv.c

475

void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info)

fs/btrfs/block-rsv.c

477

btrfs_block_rsv_release(fs_info, &fs_info->global_block_rsv, (u64)-1,

fs/btrfs/block-rsv.c

479

WARN_ON(fs_info->trans_block_rsv.size > 0);

fs/btrfs/block-rsv.c

480

WARN_ON(fs_info->trans_block_rsv.reserved > 0);

fs/btrfs/block-rsv.c

481

WARN_ON(fs_info->chunk_block_rsv.size > 0);

fs/btrfs/block-rsv.c

482

WARN_ON(fs_info->chunk_block_rsv.reserved > 0);

fs/btrfs/block-rsv.c

483

WARN_ON(fs_info->remap_block_rsv.size > 0);

fs/btrfs/block-rsv.c

484

WARN_ON(fs_info->remap_block_rsv.reserved > 0);

fs/btrfs/block-rsv.c

485

WARN_ON(fs_info->delayed_block_rsv.size > 0);

fs/btrfs/block-rsv.c

486

WARN_ON(fs_info->delayed_block_rsv.reserved > 0);

fs/btrfs/block-rsv.c

487

WARN_ON(fs_info->delayed_refs_rsv.reserved > 0);

fs/btrfs/block-rsv.c

488

WARN_ON(fs_info->delayed_refs_rsv.size > 0);

fs/btrfs/block-rsv.c

495

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/block-rsv.c

499

(root == fs_info->uuid_root) ||

fs/btrfs/block-rsv.c

507

block_rsv = &fs_info->empty_block_rsv;

fs/btrfs/block-rsv.c

516

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/block-rsv.c

518

struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;

fs/btrfs/block-rsv.c

536

btrfs_update_global_block_rsv(fs_info);

fs/btrfs/block-rsv.c

545

btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {

fs/btrfs/block-rsv.c

610

int btrfs_check_trunc_cache_free_space(const struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.c

617

needed_bytes = btrfs_calc_insert_metadata_size(fs_info, 1) +

fs/btrfs/block-rsv.c

618

btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/block-rsv.h

101

btrfs_block_rsv_release(fs_info, block_rsv, 0, NULL);

fs/btrfs/block-rsv.h

65

struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.h

67

void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.h

70

void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.h

72

int btrfs_block_rsv_add(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.h

76

int btrfs_block_rsv_refill(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.h

85

u64 btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.h

88

void btrfs_update_global_block_rsv(struct btrfs_fs_info *fs_info);

fs/btrfs/block-rsv.h

89

void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info);

fs/btrfs/block-rsv.h

90

void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info);

fs/btrfs/block-rsv.h

94

int btrfs_check_trunc_cache_free_space(const struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.h

96

static inline void btrfs_unuse_block_rsv(struct btrfs_fs_info *fs_info,

fs/btrfs/btrfs_inode.h

506

inode->root->fs_info->block_min_order,

fs/btrfs/btrfs_inode.h

507

inode->root->fs_info->block_max_order);

fs/btrfs/btrfs_inode.h

510

void btrfs_calculate_block_csum_folio(struct btrfs_fs_info *fs_info,

fs/btrfs/btrfs_inode.h

512

void btrfs_calculate_block_csum_pages(struct btrfs_fs_info *fs_info,

fs/btrfs/btrfs_inode.h

514

int btrfs_check_block_csum(struct btrfs_fs_info *fs_info, phys_addr_t paddr, u8 *csum,

fs/btrfs/btrfs_inode.h

535

int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, long nr,

fs/btrfs/btrfs_inode.h

592

void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info);

fs/btrfs/btrfs_inode.h

593

int btrfs_wait_on_delayed_iputs(struct btrfs_fs_info *fs_info);

fs/btrfs/btrfs_inode.h

603

int btrfs_encoded_io_compression_from_extent(struct btrfs_fs_info *fs_info,

fs/btrfs/compression.c

1018

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/compression.c

1031

workspace = get_workspace(fs_info, type, level);

fs/btrfs/compression.c

1056

put_workspace(fs_info, type, workspace);

fs/btrfs/compression.c

1066

struct btrfs_fs_info *fs_info = cb_to_fs_info(cb);

fs/btrfs/compression.c

1071

workspace = get_workspace(fs_info, type, 0);

fs/btrfs/compression.c

1073

put_workspace(fs_info, type, workspace);

fs/btrfs/compression.c

1089

struct btrfs_fs_info *fs_info = folio_to_fs_info(dest_folio);

fs/btrfs/compression.c

1091

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/compression.c

1101

workspace = get_workspace(fs_info, type, 0);

fs/btrfs/compression.c

1104

put_workspace(fs_info, type, workspace);

fs/btrfs/compression.c

1109

int btrfs_alloc_compress_wsm(struct btrfs_fs_info *fs_info)

fs/btrfs/compression.c

1113

ret = alloc_workspace_manager(fs_info, BTRFS_COMPRESS_NONE);

fs/btrfs/compression.c

1116

ret = alloc_workspace_manager(fs_info, BTRFS_COMPRESS_ZLIB);

fs/btrfs/compression.c

1119

ret = alloc_workspace_manager(fs_info, BTRFS_COMPRESS_LZO);

fs/btrfs/compression.c

1122

ret = zstd_alloc_workspace_manager(fs_info);

fs/btrfs/compression.c

1127

btrfs_free_compress_wsm(fs_info);

fs/btrfs/compression.c

1131

void btrfs_free_compress_wsm(struct btrfs_fs_info *fs_info)

fs/btrfs/compression.c

1133

free_workspace_manager(fs_info, BTRFS_COMPRESS_NONE);

fs/btrfs/compression.c

1134

free_workspace_manager(fs_info, BTRFS_COMPRESS_ZLIB);

fs/btrfs/compression.c

1135

free_workspace_manager(fs_info, BTRFS_COMPRESS_LZO);

fs/btrfs/compression.c

1136

zstd_free_workspace_manager(fs_info);

fs/btrfs/compression.c

1562

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/compression.c

1563

struct list_head *ws_list = get_workspace(fs_info, 0, 0);

fs/btrfs/compression.c

1632

put_workspace(fs_info, 0, ws_list);

fs/btrfs/compression.c

183

struct folio *btrfs_alloc_compr_folio(struct btrfs_fs_info *fs_info, gfp_t gfp)

fs/btrfs/compression.c

188

if (fs_info->block_min_order)

fs/btrfs/compression.c

203

return folio_alloc(gfp, fs_info->block_min_order);

fs/btrfs/compression.c

253

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/compression.c

275

btrfs_folio_clamp_clear_writeback(fs_info, folio,

fs/btrfs/compression.c

319

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/compression.c

321

ASSERT(IS_ALIGNED(ordered->file_offset, fs_info->sectorsize));

fs/btrfs/compression.c

322

ASSERT(IS_ALIGNED(ordered->num_bytes, fs_info->sectorsize));

fs/btrfs/compression.c

369

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/compression.c

390

if (fs_info->block_min_order)

fs/btrfs/compression.c

419

fs_info->sectorsize_bits;

fs/btrfs/compression.c

475

(cur + fs_info->sectorsize > btrfs_extent_map_end(em)) ||

fs/btrfs/compression.c

504

btrfs_folio_set_lock(fs_info, folio, cur, add_size);

fs/btrfs/compression.c

525

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/compression.c

529

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/compression.c

552

em = btrfs_lookup_extent_mapping(em_tree, file_offset, fs_info->sectorsize);

fs/btrfs/compression.c

580

folio = btrfs_alloc_compr_folio(fs_info, gfp);

fs/btrfs/compression.c

672

static struct list_head *alloc_heuristic_ws(struct btrfs_fs_info *fs_info)

fs/btrfs/compression.c

709

static struct list_head *alloc_workspace(struct btrfs_fs_info *fs_info, int type, int level)

fs/btrfs/compression.c

712

case BTRFS_COMPRESS_NONE: return alloc_heuristic_ws(fs_info);

fs/btrfs/compression.c

713

case BTRFS_COMPRESS_ZLIB: return zlib_alloc_workspace(fs_info, level);

fs/btrfs/compression.c

714

case BTRFS_COMPRESS_LZO: return lzo_alloc_workspace(fs_info);

fs/btrfs/compression.c

715

case BTRFS_COMPRESS_ZSTD: return zstd_alloc_workspace(fs_info, level);

fs/btrfs/compression.c

741

static int alloc_workspace_manager(struct btrfs_fs_info *fs_info,

fs/btrfs/compression.c

747

ASSERT(fs_info->compr_wsm[type] == NULL);

fs/btrfs/compression.c

756

fs_info->compr_wsm[type] = gwsm;

fs/btrfs/compression.c

762

workspace = alloc_workspace(fs_info, type, 0);

fs/btrfs/compression.c

764

btrfs_warn(fs_info,

fs/btrfs/compression.c

775

static void free_workspace_manager(struct btrfs_fs_info *fs_info,

fs/btrfs/compression.c

779

struct workspace_manager *gwsm = fs_info->compr_wsm[type];

fs/btrfs/compression.c

785

fs_info->compr_wsm[type] = NULL;

fs/btrfs/compression.c

801

struct list_head *btrfs_get_workspace(struct btrfs_fs_info *fs_info, int type, int level)

fs/btrfs/compression.c

803

struct workspace_manager *wsm = fs_info->compr_wsm[type];

fs/btrfs/compression.c

849

workspace = alloc_workspace(fs_info, type, level);

fs/btrfs/compression.c

872

btrfs_warn(fs_info,

fs/btrfs/compression.c

880

static struct list_head *get_workspace(struct btrfs_fs_info *fs_info, int type, int level)

fs/btrfs/compression.c

883

case BTRFS_COMPRESS_NONE: return btrfs_get_workspace(fs_info, type, level);

fs/btrfs/compression.c

884

case BTRFS_COMPRESS_ZLIB: return zlib_get_workspace(fs_info, level);

fs/btrfs/compression.c

885

case BTRFS_COMPRESS_LZO: return btrfs_get_workspace(fs_info, type, level);

fs/btrfs/compression.c

886

case BTRFS_COMPRESS_ZSTD: return zstd_get_workspace(fs_info, level);

fs/btrfs/compression.c

900

void btrfs_put_workspace(struct btrfs_fs_info *fs_info, int type, struct list_head *ws)

fs/btrfs/compression.c

902

struct workspace_manager *gwsm = fs_info->compr_wsm[type];

fs/btrfs/compression.c

931

static void put_workspace(struct btrfs_fs_info *fs_info, int type, struct list_head *ws)

fs/btrfs/compression.c

934

case BTRFS_COMPRESS_NONE: return btrfs_put_workspace(fs_info, type, ws);

fs/btrfs/compression.c

935

case BTRFS_COMPRESS_ZLIB: return btrfs_put_workspace(fs_info, type, ws);

fs/btrfs/compression.c

936

case BTRFS_COMPRESS_LZO: return btrfs_put_workspace(fs_info, type, ws);

fs/btrfs/compression.c

937

case BTRFS_COMPRESS_ZSTD: return zstd_put_workspace(fs_info, ws);

fs/btrfs/compression.c

987

btrfs_crit(inode->root->fs_info,

fs/btrfs/compression.h

101

struct folio *btrfs_alloc_compr_folio(struct btrfs_fs_info *fs_info, gfp_t gfp);

fs/btrfs/compression.h

115

struct list_head *btrfs_get_workspace(struct btrfs_fs_info *fs_info, int type, int level);

fs/btrfs/compression.h

116

void btrfs_put_workspace(struct btrfs_fs_info *fs_info, int type, struct list_head *ws);

fs/btrfs/compression.h

159

struct list_head *zlib_alloc_workspace(struct btrfs_fs_info *fs_info, unsigned int level);

fs/btrfs/compression.h

161

struct list_head *zlib_get_workspace(struct btrfs_fs_info *fs_info, unsigned int level);

fs/btrfs/compression.h

168

struct list_head *lzo_alloc_workspace(struct btrfs_fs_info *fs_info);

fs/btrfs/compression.h

176

int zstd_alloc_workspace_manager(struct btrfs_fs_info *fs_info);

fs/btrfs/compression.h

177

void zstd_free_workspace_manager(struct btrfs_fs_info *fs_info);

fs/btrfs/compression.h

178

struct list_head *zstd_alloc_workspace(struct btrfs_fs_info *fs_info, int level);

fs/btrfs/compression.h

180

struct list_head *zstd_get_workspace(struct btrfs_fs_info *fs_info, int level);

fs/btrfs/compression.h

181

void zstd_put_workspace(struct btrfs_fs_info *fs_info, struct list_head *ws);

fs/btrfs/compression.h

69

return cb->bbio.inode->root->fs_info;

fs/btrfs/compression.h

81

int btrfs_alloc_compress_wsm(struct btrfs_fs_info *fs_info);

fs/btrfs/compression.h

82

void btrfs_free_compress_wsm(struct btrfs_fs_info *fs_info);

fs/btrfs/ctree.c

1052

btrfs_crit(fs_info,

fs/btrfs/ctree.c

1145

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

1180

if (left_nr >= BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 1) {

fs/btrfs/ctree.c

1240

if (right_nr >= BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 1) {

fs/btrfs/ctree.c

1292

static void reada_for_search(struct btrfs_fs_info *fs_info,

fs/btrfs/ctree.c

1322

nread_max = node->fs_info->nodesize;

fs/btrfs/ctree.c

1330

blocksize = fs_info->nodesize;

fs/btrfs/ctree.c

1334

eb = find_extent_buffer(fs_info, search);

fs/btrfs/ctree.c

1466

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

1492

tmp = find_extent_buffer(fs_info, blocknr);

fs/btrfs/ctree.c

1495

reada_for_search(fs_info, p, parent_level, slot, key->objectid);

fs/btrfs/ctree.c

1547

reada_for_search(fs_info, p, parent_level, slot, key->objectid);

fs/btrfs/ctree.c

1549

tmp = btrfs_find_create_tree_block(fs_info, blocknr, check.owner_root, check.level);

fs/btrfs/ctree.c

1619

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

1623

BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 3) {

fs/btrfs/ctree.c

1636

BTRFS_NODEPTRS_PER_BLOCK(fs_info) / 2) {

fs/btrfs/ctree.c

1800

lockdep_assert_held_read(&lowest->fs_info->commit_root_sem);

fs/btrfs/ctree.c

1996

struct btrfs_fs_info *fs_info;

fs/btrfs/ctree.c

2011

fs_info = root->fs_info;

fs/btrfs/ctree.c

2053

if (!down_read_trylock(&fs_info->commit_root_sem))

fs/btrfs/ctree.c

2056

down_read(&fs_info->commit_root_sem);

fs/btrfs/ctree.c

219

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

2232

up_read(&fs_info->commit_root_sem);

fs/btrfs/ctree.c

225

spin_lock(&fs_info->trans_lock);

fs/btrfs/ctree.c

2255

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

230

&fs_info->dirty_cowonly_roots);

fs/btrfs/ctree.c

2329

b = btrfs_tree_mod_log_rewind(fs_info, b, time_seq);

fs/btrfs/ctree.c

233

&fs_info->dirty_cowonly_roots);

fs/btrfs/ctree.c

235

spin_unlock(&fs_info->trans_lock);

fs/btrfs/ctree.c

248

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

257

trans->transid != fs_info->running_transaction->transid);

fs/btrfs/ctree.c

2592

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/ctree.c

2603

btrfs_crit(fs_info,

fs/btrfs/ctree.c

2616

btrfs_crit(fs_info,

fs/btrfs/ctree.c

2675

btrfs_crit(left->fs_info, "left extent buffer:");

fs/btrfs/ctree.c

2677

btrfs_crit(left->fs_info, "right extent buffer:");

fs/btrfs/ctree.c

2679

btrfs_crit(left->fs_info,

fs/btrfs/ctree.c

2699

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/ctree.c

2707

push_items = BTRFS_NODEPTRS_PER_BLOCK(fs_info) - dst_nritems;

fs/btrfs/ctree.c

2779

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/ctree.c

2791

push_items = BTRFS_NODEPTRS_PER_BLOCK(fs_info) - dst_nritems;

fs/btrfs/ctree.c

286

write_extent_buffer_fsid(cow, fs_info->fs_devices->metadata_uuid);

fs/btrfs/ctree.c

2934

BUG_ON(nritems == BTRFS_NODEPTRS_PER_BLOCK(trans->fs_info));

fs/btrfs/ctree.c

2980

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

3008

BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 3)

fs/btrfs/ctree.c

3092

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/ctree.c

3096

ret = BTRFS_LEAF_DATA_SIZE(fs_info) - leaf_space_used(leaf, 0, nritems);

fs/btrfs/ctree.c

3098

btrfs_crit(fs_info,

fs/btrfs/ctree.c

3101

(unsigned long) BTRFS_LEAF_DATA_SIZE(fs_info),

fs/btrfs/ctree.c

3118

struct btrfs_fs_info *fs_info = right->fs_info;

fs/btrfs/ctree.c

3182

BTRFS_LEAF_DATA_SIZE(fs_info) - data_end);

fs/btrfs/ctree.c

3185

copy_leaf_data(right, left, BTRFS_LEAF_DATA_SIZE(fs_info) - push_space,

fs/btrfs/ctree.c

3196

push_space = BTRFS_LEAF_DATA_SIZE(fs_info);

fs/btrfs/ctree.c

3329

struct btrfs_fs_info *fs_info = left->fs_info;

fs/btrfs/ctree.c

3379

push_space = BTRFS_LEAF_DATA_SIZE(fs_info) -

fs/btrfs/ctree.c

3393

ioff - (BTRFS_LEAF_DATA_SIZE(fs_info) - old_left_item_size));

fs/btrfs/ctree.c

3401

btrfs_crit(fs_info, "push items (%d) > right leaf items (%u)",

fs/btrfs/ctree.c

3410

BTRFS_LEAF_DATA_SIZE(fs_info) - push_space,

fs/btrfs/ctree.c

3419

push_space = BTRFS_LEAF_DATA_SIZE(fs_info);

fs/btrfs/ctree.c

3530

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/ctree.c

3543

copy_leaf_data(right, l, BTRFS_LEAF_DATA_SIZE(fs_info) - data_copy_size,

fs/btrfs/ctree.c

3546

rt_data_off = BTRFS_LEAF_DATA_SIZE(fs_info) - btrfs_item_data_end(l, mid);

fs/btrfs/ctree.c

355

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

3663

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

3673

sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(fs_info))

fs/btrfs/ctree.c

3718

BTRFS_LEAF_DATA_SIZE(fs_info)) {

fs/btrfs/ctree.c

3725

data_size > BTRFS_LEAF_DATA_SIZE(fs_info)) {

fs/btrfs/ctree.c

3734

BTRFS_LEAF_DATA_SIZE(fs_info)) {

fs/btrfs/ctree.c

3743

data_size > BTRFS_LEAF_DATA_SIZE(fs_info)) {

fs/btrfs/ctree.c

380

ret = btrfs_lookup_extent_info(trans, fs_info, buf->start,

fs/btrfs/ctree.c

386

btrfs_crit(fs_info,

fs/btrfs/ctree.c

405

btrfs_crit(fs_info,

fs/btrfs/ctree.c

4122

btrfs_crit(leaf->fs_info, "slot %d too large, nritems %d",

fs/btrfs/ctree.c

4167

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

4196

btrfs_crit(fs_info, "not enough freespace need %u have %d",

fs/btrfs/ctree.c

4206

btrfs_crit(fs_info,

fs/btrfs/ctree.c

4465

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

4523

if (used < BTRFS_LEAF_DATA_SIZE(fs_info) / 3) {

fs/btrfs/ctree.c

473

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

4781

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

4814

if (!down_read_trylock(&fs_info->commit_root_sem)) {

fs/btrfs/ctree.c

4819

down_read(&fs_info->commit_root_sem);

fs/btrfs/ctree.c

485

trans->transid != fs_info->running_transaction->transid);

fs/btrfs/ctree.c

4954

up_read(&fs_info->commit_root_sem);

fs/btrfs/ctree.c

50

return BTRFS_LEAF_DATA_SIZE(leaf->fs_info);

fs/btrfs/ctree.c

520

write_extent_buffer_fsid(cow, fs_info->fs_devices->metadata_uuid);

fs/btrfs/ctree.c

607

if (btrfs_is_testing(root->fs_info))

fs/btrfs/ctree.c

654

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

659

btrfs_crit(fs_info,

fs/btrfs/ctree.c

671

if (unlikely(trans->transaction != fs_info->running_transaction ||

fs/btrfs/ctree.c

672

trans->transid != fs_info->generation)) {

fs/btrfs/ctree.c

674

btrfs_crit(fs_info,

fs/btrfs/ctree.c

677

fs_info->running_transaction->transid,

fs/btrfs/ctree.c

678

fs_info->generation);

fs/btrfs/ctree.c

750

btrfs_err(eb->fs_info,

fs/btrfs/ctree.c

806

btrfs_root_used(&root->root_item) + root->fs_info->nodesize);

fs/btrfs/ctree.c

814

btrfs_root_used(&root->root_item) - root->fs_info->nodesize);

fs/btrfs/ctree.c

838

return read_tree_block(parent->fs_info, btrfs_node_blockptr(parent, slot),

fs/btrfs/ctree.c

920

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

956

BTRFS_NODEPTRS_PER_BLOCK(fs_info) / 4)

fs/btrfs/ctree.h

185

struct btrfs_fs_info *fs_info;

fs/btrfs/defrag.c

1026

if (em->len >= get_extent_max_capacity(fs_info, em))

fs/btrfs/defrag.c

103

static inline bool need_auto_defrag(struct btrfs_fs_info *fs_info)

fs/btrfs/defrag.c

105

if (!btrfs_test_opt(fs_info, AUTO_DEFRAG))

fs/btrfs/defrag.c

108

if (btrfs_fs_closing(fs_info))

fs/btrfs/defrag.c

1138

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/defrag.c

1165

btrfs_folio_clamp_set_dirty(fs_info, folio, start, len);

fs/btrfs/defrag.c

1182

const u32 sectorsize = inode->root->fs_info->sectorsize;

fs/btrfs/defrag.c

121

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/defrag.c

125

if (!need_auto_defrag(fs_info))

fs/btrfs/defrag.c

1260

const u32 sectorsize = inode->root->fs_info->sectorsize;

fs/btrfs/defrag.c

1310

inode->root->fs_info->sectorsize_bits;

fs/btrfs/defrag.c

1342

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/defrag.c

1396

cur = round_down(range->start, fs_info->sectorsize);

fs/btrfs/defrag.c

1397

last_byte = round_up(last_byte, fs_info->sectorsize) - 1;

fs/btrfs/defrag.c

140

spin_lock(&fs_info->defrag_inodes_lock);

fs/btrfs/defrag.c

1412

if (btrfs_defrag_cancelled(fs_info)) {

fs/btrfs/defrag.c

1473

btrfs_set_fs_incompat(fs_info, COMPRESS_LZO);

fs/btrfs/defrag.c

1475

btrfs_set_fs_incompat(fs_info, COMPRESS_ZSTD);

fs/btrfs/defrag.c

153

spin_unlock(&fs_info->defrag_inodes_lock);

fs/btrfs/defrag.c

161

struct btrfs_fs_info *fs_info, u64 root, u64 ino)

fs/btrfs/defrag.c

172

spin_lock(&fs_info->defrag_inodes_lock);

fs/btrfs/defrag.c

173

p = fs_info->defrag_inodes.rb_node;

fs/btrfs/defrag.c

193

rb_erase(parent, &fs_info->defrag_inodes);

fs/btrfs/defrag.c

194

spin_unlock(&fs_info->defrag_inodes_lock);

fs/btrfs/defrag.c

198

void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info)

fs/btrfs/defrag.c

202

spin_lock(&fs_info->defrag_inodes_lock);

fs/btrfs/defrag.c

205

&fs_info->defrag_inodes, rb_node)

fs/btrfs/defrag.c

208

fs_info->defrag_inodes = RB_ROOT;

fs/btrfs/defrag.c

210

spin_unlock(&fs_info->defrag_inodes_lock);

fs/btrfs/defrag.c

215

static int btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info,

fs/btrfs/defrag.c

226

if (test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state))

fs/btrfs/defrag.c

228

if (!need_auto_defrag(fs_info))

fs/btrfs/defrag.c

232

inode_root = btrfs_get_fs_root(fs_info, defrag->root, true);

fs/btrfs/defrag.c

258

scoped_guard(super_write, fs_info->sb)

fs/btrfs/defrag.c

266

cur = max(cur + fs_info->sectorsize, range.start);

fs/btrfs/defrag.c

277

int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info)

fs/btrfs/defrag.c

283

atomic_inc(&fs_info->defrag_running);

fs/btrfs/defrag.c

288

if (test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state))

fs/btrfs/defrag.c

291

if (!need_auto_defrag(fs_info))

fs/btrfs/defrag.c

295

defrag = btrfs_pick_defrag_inode(fs_info, root_objectid, first_ino);

fs/btrfs/defrag.c

309

btrfs_run_defrag_inode(fs_info, defrag, &ra);

fs/btrfs/defrag.c

311

atomic_dec(&fs_info->defrag_running);

fs/btrfs/defrag.c

317

wake_up(&fs_info->transaction_wait);

fs/btrfs/defrag.c

343

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/defrag.c

344

const u32 blocksize = fs_info->nodesize;

fs/btrfs/defrag.c

357

if (unlikely(trans->transaction != fs_info->running_transaction ||

fs/btrfs/defrag.c

358

trans->transid != fs_info->generation)) {

fs/btrfs/defrag.c

360

btrfs_crit(fs_info,

fs/btrfs/defrag.c

363

fs_info->running_transaction->transid,

fs/btrfs/defrag.c

364

fs_info->generation);

fs/btrfs/defrag.c

554

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/defrag.c

572

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/defrag.c

575

if (btrfs_fs_closing(fs_info) || ret != -EAGAIN)

fs/btrfs/defrag.c

578

if (btrfs_defrag_cancelled(fs_info)) {

fs/btrfs/defrag.c

579

btrfs_debug(fs_info, "defrag_root cancelled");

fs/btrfs/defrag.c

740

const u32 sectorsize = BTRFS_I(inode)->root->fs_info->sectorsize;

fs/btrfs/defrag.c

782

static u32 get_extent_max_capacity(const struct btrfs_fs_info *fs_info,

fs/btrfs/defrag.c

787

return fs_info->max_extent_size;

fs/btrfs/defrag.c

793

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/defrag.c

818

if (next->len >= get_extent_max_capacity(fs_info, em))

fs/btrfs/defrag.c

82

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/defrag.c

85

node = rb_find_add(&defrag->rb_node, &fs_info->defrag_inodes, inode_defrag_cmp);

fs/btrfs/defrag.c

943

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/defrag.c

966

em->len <= inode->root->fs_info->max_inline)

fs/btrfs/defrag.h

22

int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);

fs/btrfs/defrag.h

23

void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info);

fs/btrfs/defrag.h

26

static inline int btrfs_defrag_cancelled(struct btrfs_fs_info *fs_info)

fs/btrfs/delalloc-space.c

116

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/delalloc-space.c

118

if (btrfs_is_zoned(fs_info) && btrfs_is_data_reloc_root(inode->root)) {

fs/btrfs/delalloc-space.c

119

ASSERT(fs_info->data_sinfo->sub_group[0]->subgroup_id ==

fs/btrfs/delalloc-space.c

121

return fs_info->data_sinfo->sub_group[0];

fs/btrfs/delalloc-space.c

123

return fs_info->data_sinfo;

fs/btrfs/delalloc-space.c

129

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delalloc-space.c

133

bytes = ALIGN(bytes, fs_info->sectorsize);

fs/btrfs/delalloc-space.c

137

else if (btrfs_is_zoned(fs_info) && btrfs_is_data_reloc_root(root))

fs/btrfs/delalloc-space.c

147

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/delalloc-space.c

152

len = round_up(start + len, fs_info->sectorsize) -

fs/btrfs/delalloc-space.c

153

round_down(start, fs_info->sectorsize);

fs/btrfs/delalloc-space.c

154

start = round_down(start, fs_info->sectorsize);

fs/btrfs/delalloc-space.c

187

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/delalloc-space.c

189

ASSERT(IS_ALIGNED(len, fs_info->sectorsize));

fs/btrfs/delalloc-space.c

204

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/delalloc-space.c

207

len = round_up(start + len, fs_info->sectorsize) -

fs/btrfs/delalloc-space.c

208

round_down(start, fs_info->sectorsize);

fs/btrfs/delalloc-space.c

209

start = round_down(start, fs_info->sectorsize);

fs/btrfs/delalloc-space.c

230

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/delalloc-space.c

240

released = btrfs_block_rsv_release(fs_info, block_rsv, 0,

fs/btrfs/delalloc-space.c

243

trace_btrfs_space_reservation(fs_info, "delalloc",

fs/btrfs/delalloc-space.c

252

static void btrfs_calculate_inode_block_rsv_size(struct btrfs_fs_info *fs_info,

fs/btrfs/delalloc-space.c

268

reserve_size = btrfs_calc_insert_metadata_size(fs_info,

fs/btrfs/delalloc-space.c

270

reserve_size += btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/delalloc-space.c

275

csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, inode->csum_bytes);

fs/btrfs/delalloc-space.c

276

reserve_size += btrfs_calc_insert_metadata_size(fs_info, csum_leaves);

fs/btrfs/delalloc-space.c

284

qgroup_rsv_size = ((u64)outstanding_extents << fs_info->nodesize_bits);

fs/btrfs/delalloc-space.c

296

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/delalloc-space.c

297

u64 nr_extents = count_max_extents(fs_info, num_bytes);

fs/btrfs/delalloc-space.c

299

u64 inode_update = btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/delalloc-space.c

304

csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, disk_num_bytes);

fs/btrfs/delalloc-space.c

306

*meta_reserve = btrfs_calc_insert_metadata_size(fs_info,

fs/btrfs/delalloc-space.c

314

*qgroup_reserve = (nr_extents << fs_info->nodesize_bits);

fs/btrfs/delalloc-space.c

321

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delalloc-space.c

344

num_bytes = ALIGN(num_bytes, fs_info->sectorsize);

fs/btrfs/delalloc-space.c

345

disk_num_bytes = ALIGN(disk_num_bytes, fs_info->sectorsize);

fs/btrfs/delalloc-space.c

376

nr_extents = count_max_extents(fs_info, num_bytes);

fs/btrfs/delalloc-space.c

381

btrfs_calculate_inode_block_rsv_size(fs_info, inode);

fs/btrfs/delalloc-space.c

386

trace_btrfs_space_reservation(root->fs_info, "delalloc",

fs/btrfs/delalloc-space.c

410

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/delalloc-space.c

412

num_bytes = ALIGN(num_bytes, fs_info->sectorsize);

fs/btrfs/delalloc-space.c

416

btrfs_calculate_inode_block_rsv_size(fs_info, inode);

fs/btrfs/delalloc-space.c

419

if (btrfs_is_testing(fs_info))

fs/btrfs/delalloc-space.c

439

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/delalloc-space.c

443

num_extents = count_max_extents(fs_info, num_bytes);

fs/btrfs/delalloc-space.c

445

btrfs_calculate_inode_block_rsv_size(fs_info, inode);

fs/btrfs/delalloc-space.c

448

if (btrfs_is_testing(fs_info))

fs/btrfs/delalloc-space.c

457

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/delalloc-space.c

458

const u32 reserved_num_extents = count_max_extents(fs_info, reserved_len);

fs/btrfs/delalloc-space.c

459

const u32 new_num_extents = count_max_extents(fs_info, new_len);

fs/btrfs/delalloc-space.c

468

btrfs_calculate_inode_block_rsv_size(fs_info, inode);

fs/btrfs/delalloc-space.c

471

if (btrfs_is_testing(fs_info))

fs/btrfs/delayed-inode.c

1001

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delayed-inode.c

1085

btrfs_delayed_inode_release_metadata(fs_info, node, (ret < 0));

fs/btrfs/delayed-inode.c

1138

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-inode.c

1154

trans->block_rsv = &fs_info->delayed_block_rsv;

fs/btrfs/delayed-inode.c

1156

curr_node = btrfs_first_delayed_node(fs_info, &curr_delayed_node_tracker);

fs/btrfs/delayed-inode.c

1232

trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv;

fs/btrfs/delayed-inode.c

1244

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/delayed-inode.c

1277

trans->block_rsv = &fs_info->delayed_block_rsv;

fs/btrfs/delayed-inode.c

1291

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/delayed-inode.c

1358

trans->block_rsv = &root->fs_info->delayed_block_rsv;

fs/btrfs/delayed-inode.c

1364

btrfs_btree_balance_dirty_nodelay(root->fs_info);

fs/btrfs/delayed-inode.c

1382

struct btrfs_fs_info *fs_info, int nr)

fs/btrfs/delayed-inode.c

1394

btrfs_queue_work(fs_info->delayed_workers, &async_work->work);

fs/btrfs/delayed-inode.c

1398

void btrfs_assert_delayed_root_empty(struct btrfs_fs_info *fs_info)

fs/btrfs/delayed-inode.c

1403

node = btrfs_first_delayed_node(fs_info, &delayed_node_tracker);

fs/btrfs/delayed-inode.c

1424

void btrfs_balance_delayed_items(struct btrfs_fs_info *fs_info)

fs/btrfs/delayed-inode.c

1426

struct btrfs_delayed_root *delayed_root = &fs_info->delayed_root;

fs/btrfs/delayed-inode.c

1429

btrfs_workqueue_normal_congested(fs_info->delayed_workers))

fs/btrfs/delayed-inode.c

1438

ret = btrfs_wq_run_delayed_node(delayed_root, fs_info, 0);

fs/btrfs/delayed-inode.c

1447

btrfs_wq_run_delayed_node(delayed_root, fs_info, BTRFS_DELAYED_BATCH);

fs/btrfs/delayed-inode.c

1452

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-inode.c

1453

const u64 bytes = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/delayed-inode.c

1455

if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))

fs/btrfs/delayed-inode.c

1465

trace_btrfs_space_reservation(fs_info, "transaction",

fs/btrfs/delayed-inode.c

1467

btrfs_block_rsv_release(fs_info, trans->block_rsv, bytes, NULL);

fs/btrfs/delayed-inode.c

1479

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-inode.c

1480

const unsigned int leaf_data_size = BTRFS_LEAF_DATA_SIZE(fs_info);

fs/btrfs/delayed-inode.c

1525

btrfs_err(trans->fs_info,

fs/btrfs/delayed-inode.c

1647

btrfs_err(trans->fs_info,

fs/btrfs/delayed-inode.c

1657

btrfs_err(trans->fs_info,

fs/btrfs/delayed-inode.c

1956

atomic_inc(&root->fs_info->delayed_root.items);

fs/btrfs/delayed-inode.c

1965

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/delayed-inode.c

1974

if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))

fs/btrfs/delayed-inode.c

1998

atomic_inc(&fs_info->delayed_root.items);

fs/btrfs/delayed-inode.c

2008

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delayed-inode.c

2036

btrfs_delayed_inode_release_metadata(fs_info, delayed_node, false);

fs/btrfs/delayed-inode.c

2099

void btrfs_destroy_delayed_inodes(struct btrfs_fs_info *fs_info)

fs/btrfs/delayed-inode.c

2104

curr_node = btrfs_first_delayed_node(fs_info, &curr_delayed_node_tracker);

fs/btrfs/delayed-inode.c

235

struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-inode.c

240

spin_lock(&fs_info->delayed_root.lock);

fs/btrfs/delayed-inode.c

241

node = list_first_entry_or_null(&fs_info->delayed_root.node_list,

fs/btrfs/delayed-inode.c

247

spin_unlock(&fs_info->delayed_root.lock);

fs/btrfs/delayed-inode.c

260

delayed_root = &node->root->fs_info->delayed_root;

fs/btrfs/delayed-inode.c

290

delayed_root = &delayed_node->root->fs_info->delayed_root;

fs/btrfs/delayed-inode.c

428

atomic_inc(&delayed_node->root->fs_info->delayed_root.items);

fs/btrfs/delayed-inode.c

462

finish_one_item(&delayed_node->root->fs_info->delayed_root);

fs/btrfs/delayed-inode.c

503

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-inode.c

511

dst_rsv = &fs_info->delayed_block_rsv;

fs/btrfs/delayed-inode.c

513

num_bytes = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/delayed-inode.c

522

trace_btrfs_space_reservation(fs_info, "delayed_item",

fs/btrfs/delayed-inode.c

541

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delayed-inode.c

546

rsv = &fs_info->delayed_block_rsv;

fs/btrfs/delayed-inode.c

551

trace_btrfs_space_reservation(fs_info, "delayed_item",

fs/btrfs/delayed-inode.c

554

btrfs_block_rsv_release(fs_info, rsv, item->bytes_reserved, NULL);

fs/btrfs/delayed-inode.c

560

struct btrfs_fs_info *fs_info = node->root->fs_info;

fs/btrfs/delayed-inode.c

561

const u64 bytes = btrfs_calc_insert_metadata_size(fs_info, num_leaves);

fs/btrfs/delayed-inode.c

564

if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))

fs/btrfs/delayed-inode.c

567

trace_btrfs_space_reservation(fs_info, "delayed_item", node->inode_id,

fs/btrfs/delayed-inode.c

569

btrfs_block_rsv_release(fs_info, &fs_info->delayed_block_rsv, bytes, NULL);

fs/btrfs/delayed-inode.c

577

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delayed-inode.c

584

dst_rsv = &fs_info->delayed_block_rsv;

fs/btrfs/delayed-inode.c

586

num_bytes = btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/delayed-inode.c

602

ret = btrfs_block_rsv_add(fs_info, dst_rsv, num_bytes,

fs/btrfs/delayed-inode.c

613

trace_btrfs_space_reservation(fs_info, "delayed_inode",

fs/btrfs/delayed-inode.c

621

static void btrfs_delayed_inode_release_metadata(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-inode.c

630

rsv = &fs_info->delayed_block_rsv;

fs/btrfs/delayed-inode.c

631

trace_btrfs_space_reservation(fs_info, "delayed_inode",

fs/btrfs/delayed-inode.c

633

btrfs_block_rsv_release(fs_info, rsv, node->bytes_reserved, NULL);

fs/btrfs/delayed-inode.c

658

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delayed-inode.c

663

const int max_size = BTRFS_LEAF_DATA_SIZE(fs_info);

fs/btrfs/delayed-inode.c

683

if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))

fs/btrfs/delayed-inode.c

845

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delayed-inode.c

903

trace_btrfs_space_reservation(fs_info, "delayed_item", ino,

fs/btrfs/delayed-inode.c

905

btrfs_block_rsv_release(fs_info, &fs_info->delayed_block_rsv,

fs/btrfs/delayed-inode.c

983

finish_one_item(&delayed_node->root->fs_info->delayed_root);

fs/btrfs/delayed-inode.c

992

finish_one_item(&delayed_node->root->fs_info->delayed_root);

fs/btrfs/delayed-inode.h

132

void btrfs_balance_delayed_items(struct btrfs_fs_info *fs_info);

fs/btrfs/delayed-inode.h

151

void btrfs_destroy_delayed_inodes(struct btrfs_fs_info *fs_info);

fs/btrfs/delayed-inode.h

178

void btrfs_assert_delayed_root_empty(struct btrfs_fs_info *fs_info);

fs/btrfs/delayed-inode.h

186

if (!btrfs_test_opt(node->root->fs_info, REF_TRACKER))

fs/btrfs/delayed-inode.h

196

if (!btrfs_test_opt(node->root->fs_info, REF_TRACKER))

fs/btrfs/delayed-inode.h

204

if (!btrfs_test_opt(node->root->fs_info, REF_TRACKER))

fs/btrfs/delayed-inode.h

222

if (!btrfs_test_opt(node->root->fs_info, REF_TRACKER))

fs/btrfs/delayed-inode.h

231

if (!btrfs_test_opt(node->root->fs_info, REF_TRACKER))

fs/btrfs/delayed-ref.c

100

num_bytes += btrfs_calc_delayed_ref_csum_bytes(fs_info,

fs/btrfs/delayed-ref.c

1035

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-ref.c

1041

const unsigned long index = (generic_ref->bytenr >> fs_info->sectorsize_bits);

fs/btrfs/delayed-ref.c

1060

if (btrfs_qgroup_full_accounting(fs_info) && !generic_ref->skip_qgroup) {

fs/btrfs/delayed-ref.c

1080

init_delayed_ref_common(fs_info, node, generic_ref);

fs/btrfs/delayed-ref.c

1118

trace_add_delayed_data_ref(trans->fs_info, node);

fs/btrfs/delayed-ref.c

1120

trace_add_delayed_tree_ref(trans->fs_info, node);

fs/btrfs/delayed-ref.c

1166

const unsigned long index = (bytenr >> trans->fs_info->sectorsize_bits);

fs/btrfs/delayed-ref.c

1226

btrfs_find_delayed_ref_head(const struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

1230

const unsigned long index = (bytenr >> fs_info->sectorsize_bits);

fs/btrfs/delayed-ref.c

1307

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-ref.c

1327

drop_delayed_ref(fs_info, delayed_refs, head, ref);

fs/btrfs/delayed-ref.c

1332

btrfs_delete_ref_head(fs_info, delayed_refs, head);

fs/btrfs/delayed-ref.c

1337

if (!btrfs_is_testing(fs_info) && pin_bytes) {

fs/btrfs/delayed-ref.c

1340

bg = btrfs_lookup_block_group(fs_info, head->bytenr);

fs/btrfs/delayed-ref.c

1348

btrfs_err(fs_info,

fs/btrfs/delayed-ref.c

135

void btrfs_inc_delayed_refs_rsv_bg_inserts(struct btrfs_fs_info *fs_info)

fs/btrfs/delayed-ref.c

1365

btrfs_error_unpin_extent_range(fs_info, head->bytenr,

fs/btrfs/delayed-ref.c

1368

if (!btrfs_is_testing(fs_info))

fs/btrfs/delayed-ref.c

1369

btrfs_cleanup_ref_head_accounting(fs_info, delayed_refs, head);

fs/btrfs/delayed-ref.c

137

struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/delayed-ref.c

1375

if (!btrfs_is_testing(fs_info))

fs/btrfs/delayed-ref.c

145

delayed_rsv->size += btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/delayed-ref.c

154

void btrfs_dec_delayed_refs_rsv_bg_inserts(struct btrfs_fs_info *fs_info)

fs/btrfs/delayed-ref.c

156

struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/delayed-ref.c

157

const u64 num_bytes = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/delayed-ref.c

160

released = btrfs_block_rsv_release(fs_info, delayed_rsv, num_bytes, NULL);

fs/btrfs/delayed-ref.c

162

trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv",

fs/btrfs/delayed-ref.c

170

void btrfs_inc_delayed_refs_rsv_bg_updates(struct btrfs_fs_info *fs_info)

fs/btrfs/delayed-ref.c

172

struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/delayed-ref.c

180

delayed_rsv->size += btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/delayed-ref.c

189

void btrfs_dec_delayed_refs_rsv_bg_updates(struct btrfs_fs_info *fs_info)

fs/btrfs/delayed-ref.c

191

struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/delayed-ref.c

192

const u64 num_bytes = btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/delayed-ref.c

195

released = btrfs_block_rsv_release(fs_info, delayed_rsv, num_bytes, NULL);

fs/btrfs/delayed-ref.c

197

trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv",

fs/btrfs/delayed-ref.c

212

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/delayed-ref.c

213

struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/delayed-ref.c

218

if (!btrfs_is_zoned(fs_info))

fs/btrfs/delayed-ref.c

234

int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

237

struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/delayed-ref.c

239

u64 limit = btrfs_calc_delayed_ref_bytes(fs_info, 1);

fs/btrfs/delayed-ref.c

291

trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv", 0,

fs/btrfs/delayed-ref.c

31

bool btrfs_check_space_for_delayed_refs(struct btrfs_fs_info *fs_info)

fs/btrfs/delayed-ref.c

33

struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/delayed-ref.c

34

struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;

fs/btrfs/delayed-ref.c

398

static inline void drop_delayed_ref(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

409

btrfs_delayed_refs_rsv_release(fs_info, 1, 0);

fs/btrfs/delayed-ref.c

412

static bool merge_ref(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

442

drop_delayed_ref(fs_info, delayed_refs, head, next);

fs/btrfs/delayed-ref.c

445

drop_delayed_ref(fs_info, delayed_refs, head, ref);

fs/btrfs/delayed-ref.c

459

void btrfs_merge_delayed_refs(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

476

seq = btrfs_tree_mod_log_lowest_seq(fs_info);

fs/btrfs/delayed-ref.c

483

if (merge_ref(fs_info, delayed_refs, head, ref, seq))

fs/btrfs/delayed-ref.c

488

int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info, u64 seq)

fs/btrfs/delayed-ref.c

491

u64 min_seq = btrfs_tree_mod_log_lowest_seq(fs_info);

fs/btrfs/delayed-ref.c

494

btrfs_debug(fs_info,

fs/btrfs/delayed-ref.c

504

const struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

515

start_index = (delayed_refs->run_delayed_start >> fs_info->sectorsize_bits);

fs/btrfs/delayed-ref.c

561

void btrfs_delete_ref_head(const struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

565

const unsigned long index = (head->bytenr >> fs_info->sectorsize_bits);

fs/btrfs/delayed-ref.c

656

drop_delayed_ref(trans->fs_info, root, href, exist);

fs/btrfs/delayed-ref.c

66

void btrfs_delayed_refs_rsv_release(struct btrfs_fs_info *fs_info, int nr_refs, int nr_csums)

fs/btrfs/delayed-ref.c

671

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-ref.c

68

struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/delayed-ref.c

72

num_bytes = btrfs_calc_delayed_ref_bytes(fs_info, nr_refs);

fs/btrfs/delayed-ref.c

73

num_bytes += btrfs_calc_delayed_ref_csum_bytes(fs_info, nr_csums);

fs/btrfs/delayed-ref.c

740

btrfs_csum_bytes_to_leaves(fs_info,

fs/btrfs/delayed-ref.c

745

btrfs_delayed_refs_rsv_release(fs_info, 0, csum_leaves);

fs/btrfs/delayed-ref.c

75

released = btrfs_block_rsv_release(fs_info, block_rsv, num_bytes, NULL);

fs/btrfs/delayed-ref.c

77

trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv",

fs/btrfs/delayed-ref.c

848

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-ref.c

851

const unsigned long index = (head_ref->bytenr >> fs_info->sectorsize_bits);

fs/btrfs/delayed-ref.c

868

btrfs_err_rl(fs_info,

fs/btrfs/delayed-ref.c

871

btrfs_err_32bit_limit(fs_info);

fs/btrfs/delayed-ref.c

886

ret = btrfs_qgroup_trace_extent_nolock(fs_info, delayed_refs, qrecord,

fs/btrfs/delayed-ref.c

898

trace_add_delayed_ref_head(fs_info, head_ref, action);

fs/btrfs/delayed-ref.c

90

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-ref.c

91

struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/delayed-ref.c

932

btrfs_csum_bytes_to_leaves(fs_info, head_ref->num_bytes);

fs/btrfs/delayed-ref.c

96

if (btrfs_is_testing(fs_info))

fs/btrfs/delayed-ref.c

965

static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

976

seq = atomic64_read(&fs_info->tree_mod_seq);

fs/btrfs/delayed-ref.c

99

num_bytes = btrfs_calc_delayed_ref_bytes(fs_info, trans->delayed_ref_updates);

fs/btrfs/delayed-ref.h

309

static inline u64 btrfs_calc_delayed_ref_bytes(const struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.h

314

num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_delayed_refs);

fs/btrfs/delayed-ref.h

324

if (btrfs_test_opt(fs_info, FREE_SPACE_TREE))

fs/btrfs/delayed-ref.h

330

static inline u64 btrfs_calc_delayed_ref_csum_bytes(const struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.h

338

return btrfs_calc_metadata_size(fs_info, num_csum_items);

fs/btrfs/delayed-ref.h

386

void btrfs_merge_delayed_refs(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.h

391

btrfs_find_delayed_ref_head(const struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.h

398

void btrfs_delete_ref_head(const struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.h

403

const struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.h

409

int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info, u64 seq);

fs/btrfs/delayed-ref.h

411

void btrfs_delayed_refs_rsv_release(struct btrfs_fs_info *fs_info, int nr_refs, int nr_csums);

fs/btrfs/delayed-ref.h

413

void btrfs_inc_delayed_refs_rsv_bg_inserts(struct btrfs_fs_info *fs_info);

fs/btrfs/delayed-ref.h

414

void btrfs_dec_delayed_refs_rsv_bg_inserts(struct btrfs_fs_info *fs_info);

fs/btrfs/delayed-ref.h

415

void btrfs_inc_delayed_refs_rsv_bg_updates(struct btrfs_fs_info *fs_info);

fs/btrfs/delayed-ref.h

416

void btrfs_dec_delayed_refs_rsv_bg_updates(struct btrfs_fs_info *fs_info);

fs/btrfs/delayed-ref.h

417

int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.h

419

bool btrfs_check_space_for_delayed_refs(struct btrfs_fs_info *fs_info);

fs/btrfs/dev-replace.c

1007

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

101

if (unlikely(btrfs_find_device(fs_info->fs_devices, &args))) {

fs/btrfs/dev-replace.c

1014

btrfs_scratch_superblocks(fs_info, src_device);

fs/btrfs/dev-replace.c

102

btrfs_err(fs_info,

fs/btrfs/dev-replace.c

1040

static u64 btrfs_dev_replace_progress(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

1042

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

1064

void btrfs_dev_replace_status(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

1067

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

1080

args->status.progress_1000 = btrfs_dev_replace_progress(fs_info);

fs/btrfs/dev-replace.c

1084

int btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

1086

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

1090

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/dev-replace.c

1094

if (sb_rdonly(fs_info->sb))

fs/btrfs/dev-replace.c

1110

ret = btrfs_scrub_cancel(fs_info);

fs/btrfs/dev-replace.c

1119

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

1143

btrfs_scrub_cancel(fs_info);

fs/btrfs/dev-replace.c

1153

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

1170

void btrfs_dev_replace_suspend_for_unmount(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

1172

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

1188

btrfs_info(fs_info, "suspending dev_replace for unmount");

fs/btrfs/dev-replace.c

1197

int btrfs_resume_dev_replace_async(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

1200

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

1218

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

1220

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

1234

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_DEV_REPLACE)) {

fs/btrfs/dev-replace.c

1239

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

1244

task = kthread_run(btrfs_dev_replace_kthread, fs_info, "btrfs-devrepl");

fs/btrfs/dev-replace.c

1250

struct btrfs_fs_info *fs_info = data;

fs/btrfs/dev-replace.c

1251

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

1255

progress = btrfs_dev_replace_progress(fs_info);

fs/btrfs/dev-replace.c

1257

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

1264

ret = btrfs_scrub_dev(fs_info, dev_replace->srcdev->devid,

fs/btrfs/dev-replace.c

1268

ret = btrfs_dev_replace_finishing(fs_info, ret);

fs/btrfs/dev-replace.c

1271

btrfs_exclop_finish(fs_info);

fs/btrfs/dev-replace.c

130

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

1302

void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount)

fs/btrfs/dev-replace.c

1304

percpu_counter_sub(&fs_info->dev_replace.bio_counter, amount);

fs/btrfs/dev-replace.c

1305

cond_wake_up_nomb(&fs_info->dev_replace.replace_wait);

fs/btrfs/dev-replace.c

1308

void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

1311

percpu_counter_inc(&fs_info->dev_replace.bio_counter);

fs/btrfs/dev-replace.c

1313

&fs_info->fs_state)))

fs/btrfs/dev-replace.c

1316

btrfs_bio_counter_dec(fs_info);

fs/btrfs/dev-replace.c

1317

wait_event(fs_info->dev_replace.replace_wait,

fs/btrfs/dev-replace.c

1319

&fs_info->fs_state));

fs/btrfs/dev-replace.c

161

if (unlikely(btrfs_find_device(fs_info->fs_devices, &args))) {

fs/btrfs/dev-replace.c

162

btrfs_err(fs_info,

fs/btrfs/dev-replace.c

172

dev_replace->tgtdev = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/dev-replace.c

174

dev_replace->srcdev = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/dev-replace.c

180

if (unlikely(!dev_replace->srcdev && !btrfs_test_opt(fs_info, DEGRADED))) {

fs/btrfs/dev-replace.c

182

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

184

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

188

if (unlikely(!dev_replace->tgtdev && !btrfs_test_opt(fs_info, DEGRADED))) {

fs/btrfs/dev-replace.c

190

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

192

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

212

WARN_ON(fs_info->fs_devices->rw_devices == 0);

fs/btrfs/dev-replace.c

213

dev_replace->tgtdev->io_width = fs_info->sectorsize;

fs/btrfs/dev-replace.c

214

dev_replace->tgtdev->io_align = fs_info->sectorsize;

fs/btrfs/dev-replace.c

215

dev_replace->tgtdev->sector_size = fs_info->sectorsize;

fs/btrfs/dev-replace.c

216

dev_replace->tgtdev->fs_info = fs_info;

fs/btrfs/dev-replace.c

232

static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

237

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/dev-replace.c

246

btrfs_err(fs_info, "the filesystem is a seed filesystem!");

fs/btrfs/dev-replace.c

251

fs_info->sb, &fs_holder_ops);

fs/btrfs/dev-replace.c

253

btrfs_err(fs_info, "target device %s is invalid!", device_path);

fs/btrfs/dev-replace.c

258

if (!btrfs_check_device_zone_type(fs_info, bdev)) {

fs/btrfs/dev-replace.c

259

btrfs_err(fs_info,

fs/btrfs/dev-replace.c

269

btrfs_err(fs_info,

fs/btrfs/dev-replace.c

278

btrfs_err(fs_info,

fs/btrfs/dev-replace.c

297

device->io_width = fs_info->sectorsize;

fs/btrfs/dev-replace.c

298

device->io_align = fs_info->sectorsize;

fs/btrfs/dev-replace.c

299

device->sector_size = fs_info->sectorsize;

fs/btrfs/dev-replace.c

305

device->fs_info = fs_info;

fs/btrfs/dev-replace.c

340

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/dev-replace.c

342

struct btrfs_root *dev_root = fs_info->dev_root;

fs/btrfs/dev-replace.c

347

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

367

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

388

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

402

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

440

static int mark_block_group_to_copy(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

446

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/dev-replace.c

455

if (!btrfs_is_zoned(fs_info))

fs/btrfs/dev-replace.c

458

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

461

spin_lock(&fs_info->trans_lock);

fs/btrfs/dev-replace.c

462

while (fs_info->running_transaction &&

fs/btrfs/dev-replace.c

463

!list_empty(&fs_info->running_transaction->dev_update_list)) {

fs/btrfs/dev-replace.c

464

spin_unlock(&fs_info->trans_lock);

fs/btrfs/dev-replace.c

465

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

469

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

471

spin_lock(&fs_info->trans_lock);

fs/btrfs/dev-replace.c

479

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

483

spin_lock(&fs_info->trans_lock);

fs/btrfs/dev-replace.c

485

spin_unlock(&fs_info->trans_lock);

fs/btrfs/dev-replace.c

517

cache = btrfs_lookup_block_group(fs_info, chunk_offset);

fs/btrfs/dev-replace.c

529

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

538

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/dev-replace.c

545

if (!btrfs_is_zoned(fs_info))

fs/btrfs/dev-replace.c

555

map = btrfs_get_chunk_map(fs_info, chunk_offset, 1);

fs/btrfs/dev-replace.c

586

static int btrfs_dev_replace_start(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

590

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/dev-replace.c

592

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

597

src_device = btrfs_find_device_by_devspec(fs_info, srcdevid,

fs/btrfs/dev-replace.c

602

if (btrfs_pinned_by_swapfile(fs_info, src_device)) {

fs/btrfs/dev-replace.c

603

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

622

ret = btrfs_init_dev_replace_tgtdev(fs_info, tgtdev_name,

fs/btrfs/dev-replace.c

627

ret = mark_block_group_to_copy(fs_info, src_device);

fs/btrfs/dev-replace.c

650

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

66

static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

674

btrfs_err(fs_info, "kobj add dev failed %d", ret);

fs/btrfs/dev-replace.c

676

btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);

fs/btrfs/dev-replace.c

70

int btrfs_init_dev_replace(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

700

ret = btrfs_scrub_dev(fs_info, src_device->devid, 0,

fs/btrfs/dev-replace.c

704

ret = btrfs_dev_replace_finishing(fs_info, ret);

fs/btrfs/dev-replace.c

732

int btrfs_dev_replace_by_ioctl(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

74

struct btrfs_root *dev_root = fs_info->dev_root;

fs/btrfs/dev-replace.c

748

ret = btrfs_dev_replace_start(fs_info, args->start.tgtdev_name,

fs/btrfs/dev-replace.c

75

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

764

static void btrfs_rm_dev_replace_blocked(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

766

set_bit(BTRFS_FS_STATE_DEV_REPLACING, &fs_info->fs_state);

fs/btrfs/dev-replace.c

767

wait_event(fs_info->dev_replace.replace_wait, !percpu_counter_sum(

fs/btrfs/dev-replace.c

768

&fs_info->dev_replace.bio_counter));

fs/btrfs/dev-replace.c

774

static void btrfs_rm_dev_replace_unblocked(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

776

clear_bit(BTRFS_FS_STATE_DEV_REPLACING, &fs_info->fs_state);

fs/btrfs/dev-replace.c

777

wake_up(&fs_info->dev_replace.replace_wait);

fs/btrfs/dev-replace.c

795

lockdep_assert_held(&srcdev->fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

812

struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

824

lockdep_assert_held(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

826

write_lock(&fs_info->mapping_tree_lock);

fs/btrfs/dev-replace.c

827

node = rb_first_cached(&fs_info->mapping_tree);

fs/btrfs/dev-replace.c

840

if (cond_resched_rwlock_write(&fs_info->mapping_tree_lock)) {

fs/btrfs/dev-replace.c

841

map = btrfs_find_chunk_map_nolock(fs_info, next_start, U64_MAX);

fs/btrfs/dev-replace.c

855

write_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/dev-replace.c

858

static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

861

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

862

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/dev-replace.c

865

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/dev-replace.c

890

ret = btrfs_start_delalloc_roots(fs_info, LONG_MAX, false);

fs/btrfs/dev-replace.c

895

btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);

fs/btrfs/dev-replace.c

914

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

918

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

941

btrfs_dev_replace_update_device_in_mapping_tree(fs_info,

fs/btrfs/dev-replace.c

946

btrfs_err(fs_info,

fs/btrfs/dev-replace.c

953

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

955

btrfs_rm_dev_replace_blocked(fs_info);

fs/btrfs/dev-replace.c

958

btrfs_rm_dev_replace_unblocked(fs_info);

fs/btrfs/dev-replace.c

964

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

988

btrfs_rm_dev_replace_blocked(fs_info);

fs/btrfs/dev-replace.c

992

btrfs_rm_dev_replace_unblocked(fs_info);

fs/btrfs/dev-replace.h

19

int btrfs_init_dev_replace(struct btrfs_fs_info *fs_info);

fs/btrfs/dev-replace.h

21

int btrfs_dev_replace_by_ioctl(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.h

23

void btrfs_dev_replace_status(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.h

25

int btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info);

fs/btrfs/dev-replace.h

26

void btrfs_dev_replace_suspend_for_unmount(struct btrfs_fs_info *fs_info);

fs/btrfs/dev-replace.h

27

int btrfs_resume_dev_replace_async(struct btrfs_fs_info *fs_info);

fs/btrfs/dev-replace.h

32

void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info);

fs/btrfs/dev-replace.h

33

void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount);

fs/btrfs/dev-replace.h

35

static inline void btrfs_bio_counter_dec(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.h

37

btrfs_bio_counter_sub(fs_info, 1);

fs/btrfs/dir-item.c

158

if (root == root->fs_info->tree_root) {

fs/btrfs/dir-item.c

270

sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(root->fs_info)) {

fs/btrfs/dir-item.c

70

if (name_len + data_len > BTRFS_MAX_XATTR_SIZE(root->fs_info))

fs/btrfs/direct-io.c

1052

static int check_direct_read(struct btrfs_fs_info *fs_info,

fs/btrfs/direct-io.c

1058

ret = check_direct_IO(fs_info, iter, offset);

fs/btrfs/direct-io.c

181

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/direct-io.c

190

ret = btrfs_reserve_extent(root, len, len, fs_info->sectorsize,

fs/btrfs/direct-io.c

193

ASSERT(btrfs_is_zoned(fs_info));

fs/btrfs/direct-io.c

194

wait_on_bit_io(&inode->root->fs_info->flags, BTRFS_FS_NEED_ZONE_FINISH,

fs/btrfs/direct-io.c

209

btrfs_dec_block_group_reservations(fs_info, ins.objectid);

fs/btrfs/direct-io.c

211

btrfs_free_reserved_extent(fs_info, ins.objectid, ins.offset, true);

fs/btrfs/direct-io.c

223

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/direct-io.c

257

bg = btrfs_inc_nocow_writers(fs_info, block_start);

fs/btrfs/direct-io.c

369

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/direct-io.c

399

len = min_t(u64, len, fs_info->sectorsize * BIO_MAX_VECS);

fs/btrfs/direct-io.c

575

iomap->bdev = fs_info->fs_devices->latest_dev->bdev;

fs/btrfs/direct-io.c

705

btrfs_warn(inode->root->fs_info,

fs/btrfs/direct-io.c

829

static ssize_t check_direct_IO(struct btrfs_fs_info *fs_info,

fs/btrfs/direct-io.c

832

const u32 blocksize_mask = fs_info->sectorsize - 1;

fs/btrfs/direct-io.c

846

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/direct-io.c

855

const u64 data_profile = btrfs_data_alloc_profile(fs_info) &

fs/btrfs/direct-io.c

916

if (check_direct_IO(fs_info, from, pos)) {

fs/btrfs/discard.c

327

!btrfs_test_opt(block_group->fs_info, DISCARD_ASYNC))

fs/btrfs/discard.c

330

discard_ctl = &block_group->fs_info->discard_ctl;

fs/btrfs/discard.c

399

if (!block_group || !btrfs_test_opt(block_group->fs_info, DISCARD_ASYNC))

fs/btrfs/discard.c

695

!btrfs_test_opt(block_group->fs_info, DISCARD_ASYNC) ||

fs/btrfs/discard.c

700

discard_ctl = &block_group->fs_info->discard_ctl;

fs/btrfs/discard.c

731

void btrfs_discard_punt_unused_bgs_list(struct btrfs_fs_info *fs_info)

fs/btrfs/discard.c

735

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/discard.c

737

list_for_each_entry_safe(block_group, next, &fs_info->unused_bgs,

fs/btrfs/discard.c

740

btrfs_discard_queue_work(&fs_info->discard_ctl, block_group);

fs/btrfs/discard.c

747

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/discard.c

782

void btrfs_discard_resume(struct btrfs_fs_info *fs_info)

fs/btrfs/discard.c

784

if (!btrfs_test_opt(fs_info, DISCARD_ASYNC)) {

fs/btrfs/discard.c

785

btrfs_discard_cleanup(fs_info);

fs/btrfs/discard.c

789

btrfs_discard_punt_unused_bgs_list(fs_info);

fs/btrfs/discard.c

791

set_bit(BTRFS_FS_DISCARD_RUNNING, &fs_info->flags);

fs/btrfs/discard.c

794

void btrfs_discard_stop(struct btrfs_fs_info *fs_info)

fs/btrfs/discard.c

796

clear_bit(BTRFS_FS_DISCARD_RUNNING, &fs_info->flags);

fs/btrfs/discard.c

799

void btrfs_discard_init(struct btrfs_fs_info *fs_info)

fs/btrfs/discard.c

801

struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl;

fs/btrfs/discard.c

823

void btrfs_discard_cleanup(struct btrfs_fs_info *fs_info)

fs/btrfs/discard.c

825

btrfs_discard_stop(fs_info);

fs/btrfs/discard.c

826

cancel_delayed_work_sync(&fs_info->discard_ctl.work);

fs/btrfs/discard.c

827

btrfs_discard_purge_list(&fs_info->discard_ctl);

fs/btrfs/discard.c

85

struct btrfs_fs_info *fs_info = container_of(discard_ctl,

fs/btrfs/discard.c

89

return (!(fs_info->sb->s_flags & SB_RDONLY) &&

fs/btrfs/discard.c

90

test_bit(BTRFS_FS_DISCARD_RUNNING, &fs_info->flags));

fs/btrfs/discard.h

34

void btrfs_discard_punt_unused_bgs_list(struct btrfs_fs_info *fs_info);

fs/btrfs/discard.h

35

void btrfs_discard_resume(struct btrfs_fs_info *fs_info);

fs/btrfs/discard.h

36

void btrfs_discard_stop(struct btrfs_fs_info *fs_info);

fs/btrfs/discard.h

37

void btrfs_discard_init(struct btrfs_fs_info *fs_info);

fs/btrfs/discard.h

38

void btrfs_discard_cleanup(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.c

1000

root = btrfs_alloc_root(fs_info, key->objectid, GFP_NOFS);

fs/btrfs/disk-io.c

1017

root->node = read_tree_block(fs_info, btrfs_root_bytenr(&root->root_item),

fs/btrfs/disk-io.c

1036

if (unlikely(!btrfs_is_testing(fs_info) &&

fs/btrfs/disk-io.c

1040

btrfs_crit(fs_info,

fs/btrfs/disk-io.c

1118

static struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1123

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

1124

root = radix_tree_lookup(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

1127

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

1131

static struct btrfs_root *btrfs_get_global_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1142

return btrfs_grab_root(fs_info->tree_root);

fs/btrfs/disk-io.c

1144

return btrfs_grab_root(btrfs_global_root(fs_info, &key));

fs/btrfs/disk-io.c

1146

return btrfs_grab_root(fs_info->chunk_root);

fs/btrfs/disk-io.c

1148

return btrfs_grab_root(fs_info->dev_root);

fs/btrfs/disk-io.c

1150

return btrfs_grab_root(btrfs_global_root(fs_info, &key));

fs/btrfs/disk-io.c

1152

return btrfs_grab_root(fs_info->quota_root);

fs/btrfs/disk-io.c

1154

return btrfs_grab_root(fs_info->uuid_root);

fs/btrfs/disk-io.c

1156

return btrfs_grab_root(fs_info->block_group_root);

fs/btrfs/disk-io.c

1158

return btrfs_grab_root(btrfs_global_root(fs_info, &key));

fs/btrfs/disk-io.c

1160

return btrfs_grab_root(fs_info->stripe_root);

fs/btrfs/disk-io.c

1162

return btrfs_grab_root(fs_info->remap_root);

fs/btrfs/disk-io.c

1168

int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1177

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

1178

ret = radix_tree_insert(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

1185

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

1191

void btrfs_check_leaked_roots(const struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1196

while (!list_empty(&fs_info->allocated_roots)) {

fs/btrfs/disk-io.c

1199

root = list_first_entry(&fs_info->allocated_roots,

fs/btrfs/disk-io.c

1201

btrfs_err(fs_info, "leaked root %s refcount %d",

fs/btrfs/disk-io.c

1212

static void free_global_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1217

while ((node = rb_first_postorder(&fs_info->global_root_tree)) != NULL) {

fs/btrfs/disk-io.c

1219

rb_erase(&root->rb_node, &fs_info->global_root_tree);

fs/btrfs/disk-io.c

1224

void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1226

struct percpu_counter *em_counter = &fs_info->evictable_extent_maps;

fs/btrfs/disk-io.c

1228

if (fs_info->fs_devices)

fs/btrfs/disk-io.c

1229

btrfs_close_devices(fs_info->fs_devices);

fs/btrfs/disk-io.c

1230

btrfs_free_compress_wsm(fs_info);

fs/btrfs/disk-io.c

1231

percpu_counter_destroy(&fs_info->stats_read_blocks);

fs/btrfs/disk-io.c

1232

percpu_counter_destroy(&fs_info->dirty_metadata_bytes);

fs/btrfs/disk-io.c

1233

percpu_counter_destroy(&fs_info->delalloc_bytes);

fs/btrfs/disk-io.c

1234

percpu_counter_destroy(&fs_info->ordered_bytes);

fs/btrfs/disk-io.c

1238

percpu_counter_destroy(&fs_info->dev_replace.bio_counter);

fs/btrfs/disk-io.c

1239

btrfs_free_stripe_hash_table(fs_info);

fs/btrfs/disk-io.c

1240

btrfs_free_ref_cache(fs_info);

fs/btrfs/disk-io.c

1241

kfree(fs_info->balance_ctl);

fs/btrfs/disk-io.c

1242

free_global_roots(fs_info);

fs/btrfs/disk-io.c

1243

btrfs_put_root(fs_info->tree_root);

fs/btrfs/disk-io.c

1244

btrfs_put_root(fs_info->chunk_root);

fs/btrfs/disk-io.c

1245

btrfs_put_root(fs_info->dev_root);

fs/btrfs/disk-io.c

1246

btrfs_put_root(fs_info->quota_root);

fs/btrfs/disk-io.c

1247

btrfs_put_root(fs_info->uuid_root);

fs/btrfs/disk-io.c

1248

btrfs_put_root(fs_info->fs_root);

fs/btrfs/disk-io.c

1249

btrfs_put_root(fs_info->data_reloc_root);

fs/btrfs/disk-io.c

1250

btrfs_put_root(fs_info->block_group_root);

fs/btrfs/disk-io.c

1251

btrfs_put_root(fs_info->stripe_root);

fs/btrfs/disk-io.c

1252

btrfs_put_root(fs_info->remap_root);

fs/btrfs/disk-io.c

1253

btrfs_check_leaked_roots(fs_info);

fs/btrfs/disk-io.c

1254

btrfs_extent_buffer_leak_debug_check(fs_info);

fs/btrfs/disk-io.c

1255

kfree(fs_info->super_copy);

fs/btrfs/disk-io.c

1256

kfree(fs_info->super_for_commit);

fs/btrfs/disk-io.c

1257

kvfree(fs_info);

fs/btrfs/disk-io.c

1279

static struct btrfs_root *btrfs_get_root_ref(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1288

root = btrfs_get_global_root(fs_info, objectid);

fs/btrfs/disk-io.c

129

btrfs_err_rl(eb->fs_info,

fs/btrfs/disk-io.c

1302

root = btrfs_lookup_fs_root(fs_info, objectid);

fs/btrfs/disk-io.c

1325

root = btrfs_read_tree_root(fs_info->tree_root, &key);

fs/btrfs/disk-io.c

1347

ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);

fs/btrfs/disk-io.c

1354

ret = btrfs_insert_fs_root(fs_info, root);

fs/btrfs/disk-io.c

1383

struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1386

return btrfs_get_root_ref(fs_info, objectid, NULL, check_ref);

fs/btrfs/disk-io.c

1397

struct btrfs_root *btrfs_get_new_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1400

return btrfs_get_root_ref(fs_info, objectid, anon_dev, true);

fs/btrfs/disk-io.c

1418

struct btrfs_root *btrfs_get_fs_root_commit_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1433

root = btrfs_get_global_root(fs_info, objectid);

fs/btrfs/disk-io.c

1437

root = btrfs_lookup_fs_root(fs_info, objectid);

fs/btrfs/disk-io.c

1444

root = read_tree_root_path(fs_info->tree_root, path, &key);

fs/btrfs/disk-io.c

1452

struct btrfs_fs_info *fs_info = arg;

fs/btrfs/disk-io.c

1458

set_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags);

fs/btrfs/disk-io.c

1461

if (btrfs_need_cleaner_sleep(fs_info))

fs/btrfs/disk-io.c

1468

if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags))

fs/btrfs/disk-io.c

1471

if (!mutex_trylock(&fs_info->cleaner_mutex))

fs/btrfs/disk-io.c

1478

if (btrfs_need_cleaner_sleep(fs_info)) {

fs/btrfs/disk-io.c

1479

mutex_unlock(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

1483

if (test_and_clear_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags))

fs/btrfs/disk-io.c

1484

btrfs_sysfs_feature_update(fs_info);

fs/btrfs/disk-io.c

1486

btrfs_run_delayed_iputs(fs_info);

fs/btrfs/disk-io.c

1488

again = btrfs_clean_one_deleted_snapshot(fs_info);

fs/btrfs/disk-io.c

1489

mutex_unlock(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

1495

btrfs_run_defrag_inodes(fs_info);

fs/btrfs/disk-io.c

1497

if (btrfs_fs_incompat(fs_info, REMAP_TREE) &&

fs/btrfs/disk-io.c

1498

!btrfs_test_opt(fs_info, DISCARD_ASYNC))

fs/btrfs/disk-io.c

1499

btrfs_handle_fully_remapped_bgs(fs_info);

fs/btrfs/disk-io.c

1509

btrfs_delete_unused_bgs(fs_info);

fs/btrfs/disk-io.c

1516

btrfs_reclaim_bgs(fs_info);

fs/btrfs/disk-io.c

1518

clear_and_wake_up_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags);

fs/btrfs/disk-io.c

1534

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/disk-io.c

1544

delay = secs_to_jiffies(fs_info->commit_interval);

fs/btrfs/disk-io.c

1545

mutex_lock(&fs_info->transaction_kthread_mutex);

fs/btrfs/disk-io.c

1547

spin_lock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

1548

cur = fs_info->running_transaction;

fs/btrfs/disk-io.c

1550

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

1555

if (!test_and_clear_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags) &&

fs/btrfs/disk-io.c

1557

delta < fs_info->commit_interval) {

fs/btrfs/disk-io.c

1558

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

156

int btrfs_check_super_csum(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1561

secs_to_jiffies(fs_info->commit_interval));

fs/btrfs/disk-io.c

1565

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

1580

wake_up_process(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

1581

mutex_unlock(&fs_info->transaction_kthread_mutex);

fs/btrfs/disk-io.c

1583

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/disk-io.c

1584

btrfs_cleanup_transaction(fs_info);

fs/btrfs/disk-io.c

1586

(!btrfs_transaction_blocked(fs_info) ||

fs/btrfs/disk-io.c

166

btrfs_csum(fs_info->csum_type, (const u8 *)disk_sb + BTRFS_CSUM_SIZE,

fs/btrfs/disk-io.c

169

if (memcmp(disk_sb->csum, result, fs_info->csum_size))

fs/btrfs/disk-io.c

1725

static int read_backup_root(struct btrfs_fs_info *fs_info, u8 priority)

fs/btrfs/disk-io.c

1727

int backup_index = find_newest_super_backup(fs_info);

fs/btrfs/disk-io.c

1728

struct btrfs_super_block *super = fs_info->super_copy;

fs/btrfs/disk-io.c

1761

static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1763

btrfs_destroy_workqueue(fs_info->delalloc_workers);

fs/btrfs/disk-io.c

1764

btrfs_destroy_workqueue(fs_info->workers);

fs/btrfs/disk-io.c

1765

if (fs_info->endio_workers)

fs/btrfs/disk-io.c

1766

destroy_workqueue(fs_info->endio_workers);

fs/btrfs/disk-io.c

1767

if (fs_info->rmw_workers)

fs/btrfs/disk-io.c

1768

destroy_workqueue(fs_info->rmw_workers);

fs/btrfs/disk-io.c

1769

btrfs_destroy_workqueue(fs_info->endio_write_workers);

fs/btrfs/disk-io.c

1770

btrfs_destroy_workqueue(fs_info->endio_freespace_worker);

fs/btrfs/disk-io.c

1771

btrfs_destroy_workqueue(fs_info->delayed_workers);

fs/btrfs/disk-io.c

1772

btrfs_destroy_workqueue(fs_info->caching_workers);

fs/btrfs/disk-io.c

1773

btrfs_destroy_workqueue(fs_info->flush_workers);

fs/btrfs/disk-io.c

1774

btrfs_destroy_workqueue(fs_info->qgroup_rescan_workers);

fs/btrfs/disk-io.c

1775

if (fs_info->discard_ctl.discard_workers)

fs/btrfs/disk-io.c

1776

destroy_workqueue(fs_info->discard_ctl.discard_workers);

fs/btrfs/disk-io.c

178

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/disk-io.c

1782

if (fs_info->endio_meta_workers)

fs/btrfs/disk-io.c

1783

destroy_workqueue(fs_info->endio_meta_workers);

fs/btrfs/disk-io.c

179

const u32 step = min(fs_info->nodesize, PAGE_SIZE);

fs/btrfs/disk-io.c

1796

static void free_global_root_pointers(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1801

&fs_info->global_root_tree,

fs/btrfs/disk-io.c

183

if (sb_rdonly(fs_info->sb))

fs/btrfs/disk-io.c

1839

spin_lock(&root->fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

1841

spin_unlock(&root->fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

1847

void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1853

while (!list_empty(&fs_info->dead_roots)) {

fs/btrfs/disk-io.c

1854

gang[0] = list_first_entry(&fs_info->dead_roots,

fs/btrfs/disk-io.c

1859

btrfs_drop_and_free_fs_root(fs_info, gang[0]);

fs/btrfs/disk-io.c

1864

ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

1870

btrfs_drop_and_free_fs_root(fs_info, gang[i]);

fs/btrfs/disk-io.c

1874

static void btrfs_init_scrub(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1876

mutex_init(&fs_info->scrub_lock);

fs/btrfs/disk-io.c

1877

atomic_set(&fs_info->scrubs_running, 0);

fs/btrfs/disk-io.c

1878

atomic_set(&fs_info->scrub_pause_req, 0);

fs/btrfs/disk-io.c

1879

atomic_set(&fs_info->scrubs_paused, 0);

fs/btrfs/disk-io.c

1880

atomic_set(&fs_info->scrub_cancel_req, 0);

fs/btrfs/disk-io.c

1881

init_waitqueue_head(&fs_info->scrub_pause_wait);

fs/btrfs/disk-io.c

1882

refcount_set(&fs_info->scrub_workers_refcnt, 0);

fs/btrfs/disk-io.c

1885

static void btrfs_init_balance(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1887

spin_lock_init(&fs_info->balance_lock);

fs/btrfs/disk-io.c

1888

mutex_init(&fs_info->balance_mutex);

fs/btrfs/disk-io.c

1889

atomic_set(&fs_info->balance_pause_req, 0);

fs/btrfs/disk-io.c

1890

atomic_set(&fs_info->balance_cancel_req, 0);

fs/btrfs/disk-io.c

1891

fs_info->balance_ctl = NULL;

fs/btrfs/disk-io.c

1892

init_waitqueue_head(&fs_info->balance_wait_q);

fs/btrfs/disk-io.c

1893

atomic_set(&fs_info->reloc_cancel_req, 0);

fs/btrfs/disk-io.c

1898

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/disk-io.c

1900

fs_info->tree_root);

fs/btrfs/disk-io.c

1918

btrfs_extent_io_tree_init(fs_info, &BTRFS_I(inode)->io_tree,

fs/btrfs/disk-io.c

1922

BTRFS_I(inode)->root = btrfs_grab_root(fs_info->tree_root);

fs/btrfs/disk-io.c

1926

fs_info->btree_inode = inode;

fs/btrfs/disk-io.c

1931

static void btrfs_init_dev_replace_locks(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1933

mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);

fs/btrfs/disk-io.c

1934

init_rwsem(&fs_info->dev_replace.rwsem);

fs/btrfs/disk-io.c

1935

init_waitqueue_head(&fs_info->dev_replace.replace_wait);

fs/btrfs/disk-io.c

1938

static void btrfs_init_qgroup(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1940

spin_lock_init(&fs_info->qgroup_lock);

fs/btrfs/disk-io.c

1941

mutex_init(&fs_info->qgroup_ioctl_lock);

fs/btrfs/disk-io.c

1942

fs_info->qgroup_tree = RB_ROOT;

fs/btrfs/disk-io.c

1943

INIT_LIST_HEAD(&fs_info->dirty_qgroups);

fs/btrfs/disk-io.c

1944

fs_info->qgroup_seq = 1;

fs/btrfs/disk-io.c

1945

fs_info->qgroup_rescan_running = false;

fs/btrfs/disk-io.c

1946

fs_info->qgroup_drop_subtree_thres = BTRFS_QGROUP_DROP_SUBTREE_THRES_DEFAULT;

fs/btrfs/disk-io.c

1947

mutex_init(&fs_info->qgroup_rescan_lock);

fs/btrfs/disk-io.c

1950

static int btrfs_init_workqueues(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1952

u32 max_active = fs_info->thread_pool_size;

fs/btrfs/disk-io.c

1956

fs_info->workers =

fs/btrfs/disk-io.c

1957

btrfs_alloc_workqueue(fs_info, "worker", flags, max_active, 16);

fs/btrfs/disk-io.c

1959

fs_info->delalloc_workers =

fs/btrfs/disk-io.c

1960

btrfs_alloc_workqueue(fs_info, "delalloc",

fs/btrfs/disk-io.c

1963

fs_info->flush_workers =

fs/btrfs/disk-io.c

1964

btrfs_alloc_workqueue(fs_info, "flush_delalloc",

fs/btrfs/disk-io.c

1967

fs_info->caching_workers =

fs/btrfs/disk-io.c

1968

btrfs_alloc_workqueue(fs_info, "cache", flags, max_active, 0);

fs/btrfs/disk-io.c

1970

fs_info->endio_workers =

fs/btrfs/disk-io.c

1972

fs_info->endio_meta_workers =

fs/btrfs/disk-io.c

1974

fs_info->rmw_workers = alloc_workqueue("btrfs-rmw", flags, max_active);

fs/btrfs/disk-io.c

1975

fs_info->endio_write_workers =

fs/btrfs/disk-io.c

1976

btrfs_alloc_workqueue(fs_info, "endio-write", flags,

fs/btrfs/disk-io.c

1978

fs_info->endio_freespace_worker =

fs/btrfs/disk-io.c

1979

btrfs_alloc_workqueue(fs_info, "freespace-write", flags,

fs/btrfs/disk-io.c

1981

fs_info->delayed_workers =

fs/btrfs/disk-io.c

1982

btrfs_alloc_workqueue(fs_info, "delayed-meta", flags,

fs/btrfs/disk-io.c

1984

fs_info->qgroup_rescan_workers =

fs/btrfs/disk-io.c

1985

btrfs_alloc_ordered_workqueue(fs_info, "qgroup-rescan",

fs/btrfs/disk-io.c

1987

fs_info->discard_ctl.discard_workers =

fs/btrfs/disk-io.c

1990

if (!(fs_info->workers &&

fs/btrfs/disk-io.c

1991

fs_info->delalloc_workers && fs_info->flush_workers &&

fs/btrfs/disk-io.c

1992

fs_info->endio_workers && fs_info->endio_meta_workers &&

fs/btrfs/disk-io.c

1993

fs_info->endio_write_workers &&

fs/btrfs/disk-io.c

1994

fs_info->endio_freespace_worker && fs_info->rmw_workers &&

fs/btrfs/disk-io.c

1995

fs_info->caching_workers &&

fs/btrfs/disk-io.c

1996

fs_info->delayed_workers && fs_info->qgroup_rescan_workers &&

fs/btrfs/disk-io.c

1997

fs_info->discard_ctl.discard_workers)) {

fs/btrfs/disk-io.c

2004

static void btrfs_init_csum_hash(struct btrfs_fs_info *fs_info, u16 csum_type)

fs/btrfs/disk-io.c

2010

set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);

fs/btrfs/disk-io.c

2013

set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);

fs/btrfs/disk-io.c

2019

btrfs_info(fs_info, "using %s checksum algorithm",

fs/btrfs/disk-io.c

2023

static int btrfs_replay_log(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

2029

struct btrfs_super_block *disk_super = fs_info->super_copy;

fs/btrfs/disk-io.c

203

return btrfs_repair_io_failure(fs_info, 0, eb->start, eb->len,

fs/btrfs/disk-io.c

2034

btrfs_err(fs_info, "log replay required on RO media");

fs/btrfs/disk-io.c

2038

log_tree_root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID,

fs/btrfs/disk-io.c

2044

check.transid = fs_info->generation + 1;

fs/btrfs/disk-io.c

2046

log_tree_root->node = read_tree_block(fs_info, bytenr, &check);

fs/btrfs/disk-io.c

2050

btrfs_err(fs_info, "failed to read log tree with error: %d", ret);

fs/btrfs/disk-io.c

2059

ASSERT(BTRFS_FS_ERROR(fs_info) != 0);

fs/btrfs/disk-io.c

2060

btrfs_err(fs_info, "failed to recover log trees with error: %d", ret);

fs/btrfs/disk-io.c

2064

if (sb_rdonly(fs_info->sb)) {

fs/btrfs/disk-io.c

2065

ret = btrfs_commit_super(fs_info);

fs/btrfs/disk-io.c

2077

struct btrfs_fs_info *fs_info = tree_root->fs_info;

fs/btrfs/disk-io.c

2090

btrfs_test_opt(fs_info, IGNOREDATACSUMS)) {

fs/btrfs/disk-io.c

2091

set_bit(BTRFS_FS_STATE_NO_DATA_CSUMS, &fs_info->fs_state);

fs/btrfs/disk-io.c

2139

fs_info->nr_global_roots = max_global_id + 1;

fs/btrfs/disk-io.c

2143

set_bit(BTRFS_FS_STATE_NO_DATA_CSUMS, &fs_info->fs_state);

fs/btrfs/disk-io.c

2145

if (!btrfs_test_opt(fs_info, IGNOREBADROOTS))

fs/btrfs/disk-io.c

2149

btrfs_err(fs_info, "failed to load root %s", name);

fs/btrfs/disk-io.c

217

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/disk-io.c

2171

if (!btrfs_fs_compat_ro(tree_root->fs_info, FREE_SPACE_TREE))

fs/btrfs/disk-io.c

2179

static int btrfs_read_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

2181

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/disk-io.c

2186

ASSERT(fs_info->tree_root);

fs/btrfs/disk-io.c

2195

if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE)) {

fs/btrfs/disk-io.c

2199

if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {

fs/btrfs/disk-io.c

2205

fs_info->block_group_root = root;

fs/btrfs/disk-io.c

2212

if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {

fs/btrfs/disk-io.c

2218

fs_info->dev_root = root;

fs/btrfs/disk-io.c

2221

ret = btrfs_init_devices_late(fs_info);

fs/btrfs/disk-io.c

2225

if (btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/disk-io.c

2227

root = fs_info->remap_root;

fs/btrfs/disk-io.c

2237

root = btrfs_read_tree_root(fs_info->tree_root, &location);

fs/btrfs/disk-io.c

2239

btrfs_err(fs_info, "data reloc tree exists when remap-tree enabled");

fs/btrfs/disk-io.c

2243

btrfs_warn(fs_info, "error %ld when checking for data reloc tree",

fs/btrfs/disk-io.c

2251

root = btrfs_get_fs_root(tree_root->fs_info,

fs/btrfs/disk-io.c

2254

if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {

fs/btrfs/disk-io.c

2261

fs_info->data_reloc_root = root;

fs/btrfs/disk-io.c

2269

fs_info->quota_root = root;

fs/btrfs/disk-io.c

2275

if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {

fs/btrfs/disk-io.c

2282

fs_info->uuid_root = root;

fs/btrfs/disk-io.c

2285

if (btrfs_fs_incompat(fs_info, RAID_STRIPE_TREE)) {

fs/btrfs/disk-io.c

2289

if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {

fs/btrfs/disk-io.c

2295

fs_info->stripe_root = root;

fs/btrfs/disk-io.c

2301

btrfs_warn(fs_info, "failed to read root (objectid=%llu): %d",

fs/btrfs/disk-io.c

2306

static int validate_sys_chunk_array(const struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

231

num_copies = btrfs_num_copies(fs_info,

fs/btrfs/disk-io.c

2318

btrfs_err(fs_info, "system chunk array too big %u > %u",

fs/btrfs/disk-io.c

2326

btrfs_err(fs_info, "system chunk array too small %u < %zu",

fs/btrfs/disk-io.c

2350

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2361

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2366

ret = btrfs_check_chunk_valid(fs_info, NULL, chunk, key.offset,

fs/btrfs/disk-io.c

2374

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2390

int btrfs_validate_super(const struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

2396

const bool ignore_flags = btrfs_test_opt(fs_info, IGNORESUPERFLAGS);

fs/btrfs/disk-io.c

2399

btrfs_err(fs_info, "no valid FS found");

fs/btrfs/disk-io.c

2404

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2409

btrfs_info(fs_info,

fs/btrfs/disk-io.c

2415

btrfs_err(fs_info, "tree_root level too big: %d >= %d",

fs/btrfs/disk-io.c

2420

btrfs_err(fs_info, "chunk_root level too big: %d >= %d",

fs/btrfs/disk-io.c

2425

btrfs_err(fs_info, "log_root level too big: %d >= %d",

fs/btrfs/disk-io.c

2436

btrfs_err(fs_info, "invalid sectorsize %llu", sectorsize);

fs/btrfs/disk-io.c

2441

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2449

btrfs_err(fs_info, "invalid nodesize %llu", nodesize);

fs/btrfs/disk-io.c

2453

btrfs_err(fs_info, "invalid leafsize %u, should be %llu",

fs/btrfs/disk-io.c

2460

btrfs_err(fs_info, "tree_root block unaligned: %llu",

fs/btrfs/disk-io.c

2465

btrfs_err(fs_info, "chunk_root block unaligned: %llu",

fs/btrfs/disk-io.c

2470

btrfs_err(fs_info, "log_root block unaligned: %llu",

fs/btrfs/disk-io.c

2475

if (unlikely(!fs_info->fs_devices->temp_fsid &&

fs/btrfs/disk-io.c

2476

memcmp(fs_info->fs_devices->fsid, sb->fsid, BTRFS_FSID_SIZE) != 0)) {

fs/btrfs/disk-io.c

2477

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2479

sb->fsid, fs_info->fs_devices->fsid);

fs/btrfs/disk-io.c

2483

if (unlikely(memcmp(fs_info->fs_devices->metadata_uuid, btrfs_sb_fsid_ptr(sb),

fs/btrfs/disk-io.c

2485

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2487

btrfs_sb_fsid_ptr(sb), fs_info->fs_devices->metadata_uuid);

fs/btrfs/disk-io.c

2491

if (unlikely(memcmp(fs_info->fs_devices->metadata_uuid, sb->dev_item.fsid,

fs/btrfs/disk-io.c

2493

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2495

fs_info->fs_devices->metadata_uuid, sb->dev_item.fsid);

fs/btrfs/disk-io.c

2503

if (unlikely(btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE) &&

fs/btrfs/disk-io.c

2504

(!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID) ||

fs/btrfs/disk-io.c

2505

!btrfs_fs_incompat(fs_info, NO_HOLES)))) {

fs/btrfs/disk-io.c

2506

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2511

if (btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/disk-io.c

2516

if (unlikely(!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID) ||

fs/btrfs/disk-io.c

2517

!btrfs_fs_incompat(fs_info, NO_HOLES) ||

fs/btrfs/disk-io.c

2518

!btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE))) {

fs/btrfs/disk-io.c

2519

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2524

if (unlikely(btrfs_fs_incompat(fs_info, MIXED_GROUPS))) {

fs/btrfs/disk-io.c

2525

btrfs_err(fs_info, "remap-tree not supported with mixed-bg");

fs/btrfs/disk-io.c

2529

if (unlikely(btrfs_fs_incompat(fs_info, ZONED))) {

fs/btrfs/disk-io.c

2530

btrfs_err(fs_info, "remap-tree not supported with zoned devices");

fs/btrfs/disk-io.c

2535

btrfs_err(fs_info, "remap-tree not supported when block size > page size");

fs/btrfs/disk-io.c

2545

btrfs_err(fs_info, "bytes_used is too small %llu",

fs/btrfs/disk-io.c

2550

btrfs_err(fs_info, "invalid stripesize %u",

fs/btrfs/disk-io.c

2555

btrfs_warn(fs_info, "suspicious number of devices: %llu",

fs/btrfs/disk-io.c

2558

btrfs_err(fs_info, "number of devices is 0");

fs/btrfs/disk-io.c

2564

btrfs_err(fs_info, "super offset mismatch %llu != %llu",

fs/btrfs/disk-io.c

2572

ret = validate_sys_chunk_array(fs_info, sb);

fs/btrfs/disk-io.c

2579

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

2585

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

2598

static int btrfs_validate_mount_super(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

2600

return btrfs_validate_super(fs_info, fs_info->super_copy, 0);

fs/btrfs/disk-io.c

2609

static int btrfs_validate_write_super(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

261

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/disk-io.c

2614

ret = btrfs_validate_super(fs_info, sb, -1);

fs/btrfs/disk-io.c

2619

btrfs_err(fs_info, "invalid csum type, has %u want %u",

fs/btrfs/disk-io.c

2625

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2633

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2647

root->node = read_tree_block(root->fs_info, bytenr, &check);

fs/btrfs/disk-io.c

2660

static int load_important_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

2662

struct btrfs_super_block *sb = fs_info->super_copy;

fs/btrfs/disk-io.c

2669

ret = load_super_root(fs_info->tree_root, bytenr, gen, level);

fs/btrfs/disk-io.c

2671

btrfs_warn(fs_info, "couldn't read tree root");

fs/btrfs/disk-io.c

2675

if (btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/disk-io.c

2679

ret = load_super_root(fs_info->remap_root, bytenr, gen, level);

fs/btrfs/disk-io.c

2681

btrfs_warn(fs_info, "couldn't read remap root");

fs/btrfs/disk-io.c

2689

static int __cold init_tree_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

2691

int backup_index = find_newest_super_backup(fs_info);

fs/btrfs/disk-io.c

2692

struct btrfs_super_block *sb = fs_info->super_copy;

fs/btrfs/disk-io.c

2693

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/disk-io.c

2704

if (!btrfs_test_opt(fs_info, USEBACKUPROOT))

fs/btrfs/disk-io.c

2707

free_root_pointers(fs_info, 0);

fs/btrfs/disk-io.c

2715

btrfs_warn(fs_info, "try to load backup roots slot %d", i);

fs/btrfs/disk-io.c

2716

ret = read_backup_root(fs_info, i);

fs/btrfs/disk-io.c

2722

ret = load_important_roots(fs_info);

fs/btrfs/disk-io.c

2740

ret = btrfs_read_roots(fs_info);

fs/btrfs/disk-io.c

2747

fs_info->generation = btrfs_header_generation(tree_root->node);

fs/btrfs/disk-io.c

2748

btrfs_set_last_trans_committed(fs_info, fs_info->generation);

fs/btrfs/disk-io.c

2749

fs_info->last_reloc_trans = 0;

fs/btrfs/disk-io.c

2753

fs_info->backup_root_index = 0;

fs/btrfs/disk-io.c

2755

fs_info->backup_root_index = backup_index + 1;

fs/btrfs/disk-io.c

2756

fs_info->backup_root_index %= BTRFS_NUM_BACKUP_ROOTS;

fs/btrfs/disk-io.c

2771

void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

2773

INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);

fs/btrfs/disk-io.c

2776

xa_init_flags(&fs_info->buffer_tree, XA_FLAGS_LOCK_IRQ | XA_FLAGS_ACCOUNT);

fs/btrfs/disk-io.c

2777

lockdep_set_class(&fs_info->buffer_tree.xa_lock, &buffer_xa_class);

fs/btrfs/disk-io.c

2779

INIT_LIST_HEAD(&fs_info->trans_list);

fs/btrfs/disk-io.c

2780

INIT_LIST_HEAD(&fs_info->dead_roots);

fs/btrfs/disk-io.c

2781

INIT_LIST_HEAD(&fs_info->delayed_iputs);

fs/btrfs/disk-io.c

2782

INIT_LIST_HEAD(&fs_info->delalloc_roots);

fs/btrfs/disk-io.c

2783

INIT_LIST_HEAD(&fs_info->caching_block_groups);

fs/btrfs/disk-io.c

2784

spin_lock_init(&fs_info->delalloc_root_lock);

fs/btrfs/disk-io.c

2785

spin_lock_init(&fs_info->trans_lock);

fs/btrfs/disk-io.c

2786

spin_lock_init(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

2787

spin_lock_init(&fs_info->delayed_iput_lock);

fs/btrfs/disk-io.c

2788

spin_lock_init(&fs_info->defrag_inodes_lock);

fs/btrfs/disk-io.c

2789

spin_lock_init(&fs_info->super_lock);

fs/btrfs/disk-io.c

2790

spin_lock_init(&fs_info->unused_bgs_lock);

fs/btrfs/disk-io.c

2791

spin_lock_init(&fs_info->treelog_bg_lock);

fs/btrfs/disk-io.c

2792

spin_lock_init(&fs_info->zone_active_bgs_lock);

fs/btrfs/disk-io.c

2793

spin_lock_init(&fs_info->relocation_bg_lock);

fs/btrfs/disk-io.c

2794

rwlock_init(&fs_info->tree_mod_log_lock);

fs/btrfs/disk-io.c

2795

rwlock_init(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

2796

mutex_init(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/disk-io.c

2797

mutex_init(&fs_info->reclaim_bgs_lock);

fs/btrfs/disk-io.c

2798

mutex_init(&fs_info->reloc_mutex);

fs/btrfs/disk-io.c

2799

spin_lock_init(&fs_info->reloc_ctl_lock);

fs/btrfs/disk-io.c

2800

mutex_init(&fs_info->delalloc_root_mutex);

fs/btrfs/disk-io.c

2801

mutex_init(&fs_info->zoned_meta_io_lock);

fs/btrfs/disk-io.c

2802

mutex_init(&fs_info->zoned_data_reloc_io_lock);

fs/btrfs/disk-io.c

2803

seqlock_init(&fs_info->profiles_lock);

fs/btrfs/disk-io.c

2805

btrfs_lockdep_init_map(fs_info, btrfs_trans_num_writers);

fs/btrfs/disk-io.c

2806

btrfs_lockdep_init_map(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/disk-io.c

2807

btrfs_lockdep_init_map(fs_info, btrfs_trans_pending_ordered);

fs/btrfs/disk-io.c

2808

btrfs_lockdep_init_map(fs_info, btrfs_ordered_extent);

fs/btrfs/disk-io.c

2809

btrfs_state_lockdep_init_map(fs_info, btrfs_trans_commit_prep,

fs/btrfs/disk-io.c

2811

btrfs_state_lockdep_init_map(fs_info, btrfs_trans_unblocked,

fs/btrfs/disk-io.c

2813

btrfs_state_lockdep_init_map(fs_info, btrfs_trans_super_committed,

fs/btrfs/disk-io.c

2815

btrfs_state_lockdep_init_map(fs_info, btrfs_trans_completed,

fs/btrfs/disk-io.c

2818

INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);

fs/btrfs/disk-io.c

2819

INIT_LIST_HEAD(&fs_info->space_info);

fs/btrfs/disk-io.c

2820

INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);

fs/btrfs/disk-io.c

2821

INIT_LIST_HEAD(&fs_info->unused_bgs);

fs/btrfs/disk-io.c

2822

INIT_LIST_HEAD(&fs_info->reclaim_bgs);

fs/btrfs/disk-io.c

2823

INIT_LIST_HEAD(&fs_info->fully_remapped_bgs);

fs/btrfs/disk-io.c

2824

INIT_LIST_HEAD(&fs_info->zone_active_bgs);

fs/btrfs/disk-io.c

2826

INIT_LIST_HEAD(&fs_info->allocated_roots);

fs/btrfs/disk-io.c

2827

INIT_LIST_HEAD(&fs_info->allocated_ebs);

fs/btrfs/disk-io.c

2828

spin_lock_init(&fs_info->eb_leak_lock);

fs/btrfs/disk-io.c

2830

fs_info->mapping_tree = RB_ROOT_CACHED;

fs/btrfs/disk-io.c

2831

rwlock_init(&fs_info->mapping_tree_lock);

fs/btrfs/disk-io.c

2832

btrfs_init_block_rsv(&fs_info->global_block_rsv,

fs/btrfs/disk-io.c

2834

btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);

fs/btrfs/disk-io.c

2835

btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);

fs/btrfs/disk-io.c

2836

btrfs_init_block_rsv(&fs_info->remap_block_rsv, BTRFS_BLOCK_RSV_REMAP);

fs/btrfs/disk-io.c

2837

btrfs_init_block_rsv(&fs_info->treelog_rsv, BTRFS_BLOCK_RSV_TREELOG);

fs/btrfs/disk-io.c

2838

btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);

fs/btrfs/disk-io.c

2839

btrfs_init_block_rsv(&fs_info->delayed_block_rsv,

fs/btrfs/disk-io.c

2841

btrfs_init_block_rsv(&fs_info->delayed_refs_rsv,

fs/btrfs/disk-io.c

2844

atomic_set(&fs_info->async_delalloc_pages, 0);

fs/btrfs/disk-io.c

2845

atomic_set(&fs_info->defrag_running, 0);

fs/btrfs/disk-io.c

2846

atomic_set(&fs_info->nr_delayed_iputs, 0);

fs/btrfs/disk-io.c

2847

atomic64_set(&fs_info->tree_mod_seq, 0);

fs/btrfs/disk-io.c

2848

fs_info->global_root_tree = RB_ROOT;

fs/btrfs/disk-io.c

2849

fs_info->max_inline = BTRFS_DEFAULT_MAX_INLINE;

fs/btrfs/disk-io.c

2850

fs_info->metadata_ratio = 0;

fs/btrfs/disk-io.c

2851

fs_info->defrag_inodes = RB_ROOT;

fs/btrfs/disk-io.c

2852

atomic64_set(&fs_info->free_chunk_space, 0);

fs/btrfs/disk-io.c

2853

fs_info->tree_mod_log = RB_ROOT;

fs/btrfs/disk-io.c

2854

fs_info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;

fs/btrfs/disk-io.c

2855

btrfs_init_ref_verify(fs_info);

fs/btrfs/disk-io.c

2857

fs_info->thread_pool_size = min_t(unsigned long,

fs/btrfs/disk-io.c

2860

INIT_LIST_HEAD(&fs_info->ordered_roots);

fs/btrfs/disk-io.c

2861

spin_lock_init(&fs_info->ordered_root_lock);

fs/btrfs/disk-io.c

2863

btrfs_init_scrub(fs_info);

fs/btrfs/disk-io.c

2864

btrfs_init_balance(fs_info);

fs/btrfs/disk-io.c

2865

btrfs_init_async_reclaim_work(fs_info);

fs/btrfs/disk-io.c

2866

btrfs_init_extent_map_shrinker_work(fs_info);

fs/btrfs/disk-io.c

2868

rwlock_init(&fs_info->block_group_cache_lock);

fs/btrfs/disk-io.c

2869

fs_info->block_group_cache_tree = RB_ROOT_CACHED;

fs/btrfs/disk-io.c

2871

btrfs_extent_io_tree_init(fs_info, &fs_info->excluded_extents,

fs/btrfs/disk-io.c

2874

mutex_init(&fs_info->ordered_operations_mutex);

fs/btrfs/disk-io.c

2875

mutex_init(&fs_info->tree_log_mutex);

fs/btrfs/disk-io.c

2876

mutex_init(&fs_info->chunk_mutex);

fs/btrfs/disk-io.c

2877

mutex_init(&fs_info->transaction_kthread_mutex);

fs/btrfs/disk-io.c

2878

mutex_init(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

2879

mutex_init(&fs_info->remap_mutex);

fs/btrfs/disk-io.c

288

ASSERT(memcmp_extent_buffer(eb, fs_info->fs_devices->metadata_uuid,

fs/btrfs/disk-io.c

2880

mutex_init(&fs_info->ro_block_group_mutex);

fs/btrfs/disk-io.c

2881

init_rwsem(&fs_info->commit_root_sem);

fs/btrfs/disk-io.c

2882

init_rwsem(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

2883

init_rwsem(&fs_info->subvol_sem);

fs/btrfs/disk-io.c

2884

sema_init(&fs_info->uuid_tree_rescan_sem, 1);

fs/btrfs/disk-io.c

2886

btrfs_init_dev_replace_locks(fs_info);

fs/btrfs/disk-io.c

2887

btrfs_init_qgroup(fs_info);

fs/btrfs/disk-io.c

2888

btrfs_discard_init(fs_info);

fs/btrfs/disk-io.c

2890

btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);

fs/btrfs/disk-io.c

2891

btrfs_init_free_cluster(&fs_info->data_alloc_cluster);

fs/btrfs/disk-io.c

2893

init_waitqueue_head(&fs_info->transaction_throttle);

fs/btrfs/disk-io.c

2894

init_waitqueue_head(&fs_info->transaction_wait);

fs/btrfs/disk-io.c

2895

init_waitqueue_head(&fs_info->transaction_blocked_wait);

fs/btrfs/disk-io.c

2896

init_waitqueue_head(&fs_info->async_submit_wait);

fs/btrfs/disk-io.c

2897

init_waitqueue_head(&fs_info->delayed_iputs_wait);

fs/btrfs/disk-io.c

2900

fs_info->nodesize = 4096;

fs/btrfs/disk-io.c

2901

fs_info->sectorsize = 4096;

fs/btrfs/disk-io.c

2902

fs_info->sectorsize_bits = ilog2(4096);

fs/btrfs/disk-io.c

2903

fs_info->stripesize = 4096;

fs/btrfs/disk-io.c

2906

fs_info->compress_type = BTRFS_COMPRESS_ZLIB;

fs/btrfs/disk-io.c

2908

fs_info->max_extent_size = BTRFS_MAX_EXTENT_SIZE;

fs/btrfs/disk-io.c

2910

spin_lock_init(&fs_info->swapfile_pins_lock);

fs/btrfs/disk-io.c

2911

fs_info->swapfile_pins = RB_ROOT;

fs/btrfs/disk-io.c

2913

fs_info->bg_reclaim_threshold = BTRFS_DEFAULT_RECLAIM_THRESH;

fs/btrfs/disk-io.c

2914

INIT_WORK(&fs_info->reclaim_bgs_work, btrfs_reclaim_bgs_work);

fs/btrfs/disk-io.c

2917

static int init_mount_fs_info(struct btrfs_fs_info *fs_info, struct super_block *sb)

fs/btrfs/disk-io.c

2921

fs_info->sb = sb;

fs/btrfs/disk-io.c

2926

ret = percpu_counter_init(&fs_info->ordered_bytes, 0, GFP_KERNEL);

fs/btrfs/disk-io.c

2930

ret = percpu_counter_init(&fs_info->evictable_extent_maps, 0, GFP_KERNEL);

fs/btrfs/disk-io.c

2934

ret = percpu_counter_init(&fs_info->dirty_metadata_bytes, 0, GFP_KERNEL);

fs/btrfs/disk-io.c

2938

ret = percpu_counter_init(&fs_info->stats_read_blocks, 0, GFP_KERNEL);

fs/btrfs/disk-io.c

2942

fs_info->dirty_metadata_batch = PAGE_SIZE *

fs/btrfs/disk-io.c

2945

ret = percpu_counter_init(&fs_info->delalloc_bytes, 0, GFP_KERNEL);

fs/btrfs/disk-io.c

2949

ret = percpu_counter_init(&fs_info->dev_replace.bio_counter, 0,

fs/btrfs/disk-io.c

2954

btrfs_init_delayed_root(&fs_info->delayed_root);

fs/btrfs/disk-io.c

2957

set_bit(BTRFS_FS_STATE_RO, &fs_info->fs_state);

fs/btrfs/disk-io.c

2958

if (btrfs_test_opt(fs_info, IGNOREMETACSUMS))

fs/btrfs/disk-io.c

2959

set_bit(BTRFS_FS_STATE_SKIP_META_CSUMS, &fs_info->fs_state);

fs/btrfs/disk-io.c

2961

return btrfs_alloc_stripe_hash_table(fs_info);

fs/btrfs/disk-io.c

2966

struct btrfs_fs_info *fs_info = data;

fs/btrfs/disk-io.c

2974

ret = btrfs_uuid_tree_iterate(fs_info);

fs/btrfs/disk-io.c

2977

btrfs_warn(fs_info, "iterating uuid_tree failed %d",

fs/btrfs/disk-io.c

2979

up(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/disk-io.c

2985

static int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

2989

down(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/disk-io.c

2990

task = kthread_run(btrfs_uuid_rescan_kthread, fs_info, "btrfs-uuid");

fs/btrfs/disk-io.c

2993

up(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/disk-io.c

3000

static int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

3009

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

3010

found = radix_tree_gang_lookup(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

3014

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

3028

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

305

last_trans = btrfs_get_last_trans_committed(fs_info);

fs/btrfs/disk-io.c

3055

int btrfs_start_pre_rw_mount(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

3058

const bool cache_opt = btrfs_test_opt(fs_info, SPACE_CACHE);

fs/btrfs/disk-io.c

3061

if (btrfs_test_opt(fs_info, CLEAR_CACHE) &&

fs/btrfs/disk-io.c

3062

btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {

fs/btrfs/disk-io.c

3063

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))

fs/btrfs/disk-io.c

3064

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3066

else if (btrfs_fs_incompat(fs_info, REMAP_TREE))

fs/btrfs/disk-io.c

3067

btrfs_warn(fs_info, "'clear_cache' option is ignored with remap tree");

fs/btrfs/disk-io.c

3070

} else if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&

fs/btrfs/disk-io.c

3071

!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID)) {

fs/btrfs/disk-io.c

3072

btrfs_warn(fs_info, "free space tree is invalid");

fs/btrfs/disk-io.c

3077

btrfs_info(fs_info, "rebuilding free space tree");

fs/btrfs/disk-io.c

3078

ret = btrfs_rebuild_free_space_tree(fs_info);

fs/btrfs/disk-io.c

308

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3080

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3086

if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&

fs/btrfs/disk-io.c

3087

!btrfs_test_opt(fs_info, FREE_SPACE_TREE)) {

fs/btrfs/disk-io.c

3088

btrfs_info(fs_info, "disabling free space tree");

fs/btrfs/disk-io.c

3089

ret = btrfs_delete_free_space_tree(fs_info);

fs/btrfs/disk-io.c

3091

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3101

ret = btrfs_delete_orphan_free_space_entries(fs_info);

fs/btrfs/disk-io.c

3103

btrfs_err(fs_info, "failed to delete orphan free space tree entries: %d", ret);

fs/btrfs/disk-io.c

3117

ret = btrfs_find_orphan_roots(fs_info);

fs/btrfs/disk-io.c

3121

ret = btrfs_cleanup_fs_roots(fs_info);

fs/btrfs/disk-io.c

3125

down_read(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

3126

if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||

fs/btrfs/disk-io.c

3127

(ret = btrfs_orphan_cleanup(fs_info->tree_root))) {

fs/btrfs/disk-io.c

3128

up_read(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

313

write_extent_buffer(eb, result, 0, fs_info->csum_size);

fs/btrfs/disk-io.c

3131

up_read(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

3133

mutex_lock(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

3134

ret = btrfs_recover_relocation(fs_info);

fs/btrfs/disk-io.c

3135

mutex_unlock(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

3137

btrfs_warn(fs_info, "failed to recover relocation: %d", ret);

fs/btrfs/disk-io.c

3141

if (btrfs_test_opt(fs_info, FREE_SPACE_TREE) &&

fs/btrfs/disk-io.c

3142

!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {

fs/btrfs/disk-io.c

3143

btrfs_info(fs_info, "creating free space tree");

fs/btrfs/disk-io.c

3144

ret = btrfs_create_free_space_tree(fs_info);

fs/btrfs/disk-io.c

3146

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3152

if (cache_opt != btrfs_free_space_cache_v1_active(fs_info)) {

fs/btrfs/disk-io.c

3153

ret = btrfs_set_free_space_cache_v1_active(fs_info, cache_opt);

fs/btrfs/disk-io.c

3158

ret = btrfs_resume_balance_async(fs_info);

fs/btrfs/disk-io.c

3162

ret = btrfs_resume_dev_replace_async(fs_info);

fs/btrfs/disk-io.c

3164

btrfs_warn(fs_info, "failed to resume dev_replace");

fs/btrfs/disk-io.c

3168

btrfs_qgroup_rescan_resume(fs_info);

fs/btrfs/disk-io.c

3170

if (!fs_info->uuid_root) {

fs/btrfs/disk-io.c

3171

btrfs_info(fs_info, "creating UUID tree");

fs/btrfs/disk-io.c

3172

ret = btrfs_create_uuid_tree(fs_info);

fs/btrfs/disk-io.c

3174

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

318

btrfs_err(fs_info, "block=%llu write time tree block corruption detected",

fs/btrfs/disk-io.c

3198

int btrfs_check_features(struct btrfs_fs_info *fs_info, bool is_rw_mount)

fs/btrfs/disk-io.c

3200

struct btrfs_super_block *disk_super = fs_info->super_copy;

fs/btrfs/disk-io.c

3206

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3214

(fs_info->sectorsize != fs_info->nodesize)) {

fs/btrfs/disk-io.c

3215

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3217

fs_info->nodesize, fs_info->sectorsize);

fs/btrfs/disk-io.c

3225

if (fs_info->compress_type == BTRFS_COMPRESS_LZO)

fs/btrfs/disk-io.c

3227

else if (fs_info->compress_type == BTRFS_COMPRESS_ZSTD)

fs/btrfs/disk-io.c

3238

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3250

!btrfs_test_opt(fs_info, NOLOGREPLAY)) {

fs/btrfs/disk-io.c

3251

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3261

if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE) &&

fs/btrfs/disk-io.c

3262

(!btrfs_fs_incompat(fs_info, NO_HOLES) ||

fs/btrfs/disk-io.c

3263

!btrfs_test_opt(fs_info, FREE_SPACE_TREE))) {

fs/btrfs/disk-io.c

3264

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3276

if (fs_info->sectorsize != PAGE_SIZE && btrfs_test_opt(fs_info, SPACE_CACHE)) {

fs/btrfs/disk-io.c

3277

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3279

PAGE_SIZE, fs_info->sectorsize);

fs/btrfs/disk-io.c

3284

spin_lock(&fs_info->super_lock);

fs/btrfs/disk-io.c

3286

spin_unlock(&fs_info->super_lock);

fs/btrfs/disk-io.c

3296

static void invalidate_and_check_btree_folios(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

3302

ret = invalidate_inode_pages2(fs_info->btree_inode->i_mapping);

fs/btrfs/disk-io.c

3311

xa_for_each(&fs_info->buffer_tree, index, eb) {

fs/btrfs/disk-io.c

3327

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

333

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/disk-io.c

3337

invalidate_inode_pages2(fs_info->btree_inode->i_mapping);

fs/btrfs/disk-io.c

334

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;

fs/btrfs/disk-io.c

3357

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/disk-io.c

3364

ret = init_mount_fs_info(fs_info, sb);

fs/btrfs/disk-io.c

3369

tree_root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID,

fs/btrfs/disk-io.c

3371

fs_info->tree_root = tree_root;

fs/btrfs/disk-io.c

3372

chunk_root = btrfs_alloc_root(fs_info, BTRFS_CHUNK_TREE_OBJECTID,

fs/btrfs/disk-io.c

3374

fs_info->chunk_root = chunk_root;

fs/btrfs/disk-io.c

3395

btrfs_info(fs_info, "first mount of filesystem %pU", disk_super->fsid);

fs/btrfs/disk-io.c

3402

btrfs_err(fs_info, "unsupported checksum algorithm: %u",

fs/btrfs/disk-io.c

3409

fs_info->csum_size = btrfs_super_csum_size(disk_super);

fs/btrfs/disk-io.c

3410

fs_info->csum_type = csum_type;

fs/btrfs/disk-io.c

3412

btrfs_init_csum_hash(fs_info, csum_type);

fs/btrfs/disk-io.c

3418

if (btrfs_check_super_csum(fs_info, disk_super)) {

fs/btrfs/disk-io.c

3419

btrfs_err(fs_info, "superblock checksum mismatch");

fs/btrfs/disk-io.c

3430

memcpy(fs_info->super_copy, disk_super, sizeof(*fs_info->super_copy));

fs/btrfs/disk-io.c

3433

disk_super = fs_info->super_copy;

fs/btrfs/disk-io.c

3435

memcpy(fs_info->super_for_commit, fs_info->super_copy,

fs/btrfs/disk-io.c

3436

sizeof(*fs_info->super_for_commit));

fs/btrfs/disk-io.c

3438

ret = btrfs_validate_mount_super(fs_info);

fs/btrfs/disk-io.c

3440

btrfs_err(fs_info, "superblock contains fatal errors");

fs/btrfs/disk-io.c

3446

btrfs_err(fs_info, "invalid superblock tree root bytenr");

fs/btrfs/disk-io.c

3453

WRITE_ONCE(fs_info->fs_error, -EUCLEAN);

fs/btrfs/disk-io.c

3456

if (btrfs_is_full_ro(fs_info))

fs/btrfs/disk-io.c

3457

WRITE_ONCE(fs_info->fs_error, -EROFS);

fs/btrfs/disk-io.c

346

if (memcmp(fsid, fs_info->fs_devices->metadata_uuid, BTRFS_FSID_SIZE) == 0)

fs/btrfs/disk-io.c

3463

fs_info->dirty_metadata_batch = nodesize * (1 + ilog2(nr_cpu_ids));

fs/btrfs/disk-io.c

3464

fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));

fs/btrfs/disk-io.c

3466

fs_info->nodesize = nodesize;

fs/btrfs/disk-io.c

3467

fs_info->nodesize_bits = ilog2(nodesize);

fs/btrfs/disk-io.c

3468

fs_info->sectorsize = sectorsize;

fs/btrfs/disk-io.c

3469

fs_info->sectorsize_bits = ilog2(sectorsize);

fs/btrfs/disk-io.c

3470

fs_info->block_min_order = ilog2(round_up(sectorsize, PAGE_SIZE) >> PAGE_SHIFT);

fs/btrfs/disk-io.c

3471

fs_info->block_max_order = calc_block_max_order(fs_info->sectorsize_bits);

fs/btrfs/disk-io.c

3472

fs_info->csums_per_leaf = BTRFS_MAX_ITEM_SIZE(fs_info) / fs_info->csum_size;

fs/btrfs/disk-io.c

3473

fs_info->stripesize = stripesize;

fs/btrfs/disk-io.c

3474

fs_info->fs_devices->fs_info = fs_info;

fs/btrfs/disk-io.c

3476

if (fs_info->sectorsize > PAGE_SIZE)

fs/btrfs/disk-io.c

3477

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3479

fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/disk-io.c

3484

btrfs_set_free_space_cache_settings(fs_info);

fs/btrfs/disk-io.c

3486

if (!btrfs_check_options(fs_info, &fs_info->mount_opt, sb->s_flags)) {

fs/btrfs/disk-io.c

3491

ret = btrfs_check_features(fs_info, !sb_rdonly(sb));

fs/btrfs/disk-io.c

3496

remap_root = btrfs_alloc_root(fs_info, BTRFS_REMAP_TREE_OBJECTID,

fs/btrfs/disk-io.c

3498

fs_info->remap_root = remap_root;

fs/btrfs/disk-io.c

3509

fs_info->max_inline = min_t(u64, fs_info->max_inline, fs_info->sectorsize);

fs/btrfs/disk-io.c

3511

ret = btrfs_alloc_compress_wsm(fs_info);

fs/btrfs/disk-io.c

3514

ret = btrfs_init_workqueues(fs_info);

fs/btrfs/disk-io.c

3530

if (fs_info->fs_devices->temp_fsid)

fs/btrfs/disk-io.c

3531

memcpy(&sb->s_uuid, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);

fs/btrfs/disk-io.c

3533

memcpy(&sb->s_uuid, fs_info->fs_devices->fsid, BTRFS_FSID_SIZE);

fs/btrfs/disk-io.c

3535

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/disk-io.c

3536

ret = btrfs_read_sys_array(fs_info);

fs/btrfs/disk-io.c

3537

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/disk-io.c

3539

btrfs_err(fs_info, "failed to read the system array: %d", ret);

fs/btrfs/disk-io.c

3548

btrfs_err(fs_info, "failed to read chunk root");

fs/btrfs/disk-io.c

3552

read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,

fs/btrfs/disk-io.c

3556

ret = btrfs_read_chunk_tree(fs_info);

fs/btrfs/disk-io.c

3558

btrfs_err(fs_info, "failed to read chunk tree: %d", ret);

fs/btrfs/disk-io.c

3571

btrfs_err(fs_info, "failed to read devices");

fs/btrfs/disk-io.c

3576

ret = init_tree_roots(fs_info);

fs/btrfs/disk-io.c

3585

ret = btrfs_get_dev_zone_info_all_devices(fs_info);

fs/btrfs/disk-io.c

3587

btrfs_err(fs_info,

fs/btrfs/disk-io.c

360

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/disk-io.c

3600

if (fs_info->uuid_root && !btrfs_test_opt(fs_info, RESCAN_UUID_TREE) &&

fs/btrfs/disk-io.c

3601

fs_info->generation == btrfs_super_uuid_tree_generation(disk_super))

fs/btrfs/disk-io.c

3602

set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);

fs/btrfs/disk-io.c

3604

if (unlikely(btrfs_verify_dev_items(fs_info))) {

fs/btrfs/disk-io.c

3608

ret = btrfs_verify_dev_extents(fs_info);

fs/btrfs/disk-io.c

3610

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3615

ret = btrfs_recover_balance(fs_info);

fs/btrfs/disk-io.c

3617

btrfs_err(fs_info, "failed to recover balance: %d", ret);

fs/btrfs/disk-io.c

362

const u32 csum_size = fs_info->csum_size;

fs/btrfs/disk-io.c

3621

ret = btrfs_init_dev_stats(fs_info);

fs/btrfs/disk-io.c

3623

btrfs_err(fs_info, "failed to init dev_stats: %d", ret);

fs/btrfs/disk-io.c

3627

ret = btrfs_init_dev_replace(fs_info);

fs/btrfs/disk-io.c

3629

btrfs_err(fs_info, "failed to init dev_replace: %d", ret);

fs/btrfs/disk-io.c

3633

ret = btrfs_check_zoned_mode(fs_info);

fs/btrfs/disk-io.c

3635

btrfs_err(fs_info, "failed to initialize zoned mode: %d",

fs/btrfs/disk-io.c

3642

btrfs_err(fs_info, "failed to init sysfs fsid interface: %d",

fs/btrfs/disk-io.c

3647

ret = btrfs_sysfs_add_mounted(fs_info);

fs/btrfs/disk-io.c

3649

btrfs_err(fs_info, "failed to init sysfs interface: %d", ret);

fs/btrfs/disk-io.c

3653

ret = btrfs_init_space_info(fs_info);

fs/btrfs/disk-io.c

3655

btrfs_err(fs_info, "failed to initialize space info: %d", ret);

fs/btrfs/disk-io.c

3659

ret = btrfs_read_block_groups(fs_info);

fs/btrfs/disk-io.c

3661

btrfs_err(fs_info, "failed to read block groups: %d", ret);

fs/btrfs/disk-io.c

3665

if (btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/disk-io.c

3666

ret = btrfs_populate_fully_remapped_bgs_list(fs_info);

fs/btrfs/disk-io.c

3668

btrfs_err(fs_info, "failed to populate fully_remapped_bgs list: %d", ret);

fs/btrfs/disk-io.c

367

const bool ignore_csum = btrfs_test_opt(fs_info, IGNOREMETACSUMS);

fs/btrfs/disk-io.c

3673

ret = btrfs_init_writeback_bio_size(fs_info);

fs/btrfs/disk-io.c

3675

btrfs_err(fs_info, "failed to get optimum writeback size: %d",

fs/btrfs/disk-io.c

3680

btrfs_free_zone_cache(fs_info);

fs/btrfs/disk-io.c

3682

btrfs_check_active_zone_reservation(fs_info);

fs/btrfs/disk-io.c

3684

if (!sb_rdonly(sb) && fs_info->fs_devices->missing_devices &&

fs/btrfs/disk-io.c

3685

!btrfs_check_rw_degradable(fs_info, NULL)) {

fs/btrfs/disk-io.c

3686

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3692

fs_info->cleaner_kthread = kthread_run(cleaner_kthread, fs_info,

fs/btrfs/disk-io.c

3694

if (IS_ERR(fs_info->cleaner_kthread)) {

fs/btrfs/disk-io.c

3695

ret = PTR_ERR(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

3699

fs_info->transaction_kthread = kthread_run(transaction_kthread,

fs/btrfs/disk-io.c

3702

if (IS_ERR(fs_info->transaction_kthread)) {

fs/btrfs/disk-io.c

3703

ret = PTR_ERR(fs_info->transaction_kthread);

fs/btrfs/disk-io.c

3711

btrfs_zoned_reserve_data_reloc_bg(fs_info);

fs/btrfs/disk-io.c

3713

ret = btrfs_read_qgroup_config(fs_info);

fs/btrfs/disk-io.c

3717

if (btrfs_build_ref_tree(fs_info))

fs/btrfs/disk-io.c

3718

btrfs_err(fs_info, "couldn't build ref tree");

fs/btrfs/disk-io.c

3722

!btrfs_test_opt(fs_info, NOLOGREPLAY)) {

fs/btrfs/disk-io.c

3723

btrfs_info(fs_info, "start tree-log replay");

fs/btrfs/disk-io.c

3724

ret = btrfs_replay_log(fs_info, fs_devices);

fs/btrfs/disk-io.c

3729

fs_info->fs_root = btrfs_get_fs_root(fs_info, BTRFS_FS_TREE_OBJECTID, true);

fs/btrfs/disk-io.c

373

btrfs_err_rl(fs_info,

fs/btrfs/disk-io.c

3730

if (IS_ERR(fs_info->fs_root)) {

fs/btrfs/disk-io.c

3731

ret = PTR_ERR(fs_info->fs_root);

fs/btrfs/disk-io.c

3732

btrfs_err(fs_info, "failed to read fs tree: %d", ret);

fs/btrfs/disk-io.c

3733

fs_info->fs_root = NULL;

fs/btrfs/disk-io.c

3740

ret = btrfs_start_pre_rw_mount(fs_info);

fs/btrfs/disk-io.c

3742

close_ctree(fs_info);

fs/btrfs/disk-io.c

3745

btrfs_discard_resume(fs_info);

fs/btrfs/disk-io.c

3747

if (fs_info->uuid_root &&

fs/btrfs/disk-io.c

3748

(btrfs_test_opt(fs_info, RESCAN_UUID_TREE) ||

fs/btrfs/disk-io.c

3749

!test_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags))) {

fs/btrfs/disk-io.c

3750

btrfs_info(fs_info, "checking UUID tree");

fs/btrfs/disk-io.c

3751

ret = btrfs_check_uuid_tree(fs_info);

fs/btrfs/disk-io.c

3753

btrfs_err(fs_info, "failed to check the UUID tree: %d", ret);

fs/btrfs/disk-io.c

3754

close_ctree(fs_info);

fs/btrfs/disk-io.c

3759

set_bit(BTRFS_FS_OPEN, &fs_info->flags);

fs/btrfs/disk-io.c

3762

if (test_bit(BTRFS_FS_UNFINISHED_DROPS, &fs_info->flags))

fs/btrfs/disk-io.c

3763

wake_up_process(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

3768

btrfs_free_qgroup_config(fs_info);

fs/btrfs/disk-io.c

3770

kthread_stop(fs_info->transaction_kthread);

fs/btrfs/disk-io.c

3771

btrfs_cleanup_transaction(fs_info);

fs/btrfs/disk-io.c

3772

btrfs_free_fs_roots(fs_info);

fs/btrfs/disk-io.c

3774

kthread_stop(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

3780

filemap_write_and_wait(fs_info->btree_inode->i_mapping);

fs/btrfs/disk-io.c

3783

btrfs_sysfs_remove_mounted(fs_info);

fs/btrfs/disk-io.c

3786

btrfs_sysfs_remove_fsid(fs_info->fs_devices);

fs/btrfs/disk-io.c

3789

btrfs_put_block_group_cache(fs_info);

fs/btrfs/disk-io.c

379

btrfs_err_rl(fs_info, "bad fsid on logical %llu mirror %u",

fs/btrfs/disk-io.c

3792

if (fs_info->data_reloc_root)

fs/btrfs/disk-io.c

3793

btrfs_drop_and_free_fs_root(fs_info, fs_info->data_reloc_root);

fs/btrfs/disk-io.c

3794

free_root_pointers(fs_info, true);

fs/btrfs/disk-io.c

3795

invalidate_and_check_btree_folios(fs_info);

fs/btrfs/disk-io.c

3798

btrfs_stop_all_workers(fs_info);

fs/btrfs/disk-io.c

3799

btrfs_free_block_groups(fs_info);

fs/btrfs/disk-io.c

3801

btrfs_mapping_tree_free(fs_info);

fs/btrfs/disk-io.c

3803

iput(fs_info->btree_inode);

fs/btrfs/disk-io.c

3817

btrfs_warn_rl(device->fs_info,

fs/btrfs/disk-io.c

3849

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/disk-io.c

385

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3868

btrfs_err(device->fs_info,

fs/btrfs/disk-io.c

3880

btrfs_csum(fs_info->csum_type, (const u8 *)sb + BTRFS_CSUM_SIZE,

fs/btrfs/disk-io.c

3887

btrfs_err(device->fs_info,

fs/btrfs/disk-io.c

3916

if (i == 0 && !btrfs_test_opt(device->fs_info, NOBARRIER))

fs/btrfs/disk-io.c

396

btrfs_warn_rl(fs_info,

fs/btrfs/disk-io.c

3971

btrfs_err(device->fs_info, "error writing primary super block to device %llu",

fs/btrfs/disk-io.c

408

btrfs_err(fs_info,

fs/btrfs/disk-io.c

4112

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/disk-io.c

4123

do_barriers = !btrfs_test_opt(fs_info, NOBARRIER);

fs/btrfs/disk-io.c

4131

ret = backup_super_roots(fs_info);

fs/btrfs/disk-io.c

4136

sb = fs_info->super_for_commit;

fs/btrfs/disk-io.c

4139

mutex_lock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/disk-io.c

4140

head = &fs_info->fs_devices->devices;

fs/btrfs/disk-io.c

4141

max_errors = btrfs_super_num_devices(fs_info->super_copy) - 1;

fs/btrfs/disk-io.c

4144

ret = barrier_all_devices(fs_info);

fs/btrfs/disk-io.c

4147

&fs_info->fs_devices->device_list_mutex);

fs/btrfs/disk-io.c

4149

btrfs_err(fs_info, "error while submitting device barriers");

fs/btrfs/disk-io.c

415

btrfs_err_rl(eb->fs_info,

fs/btrfs/disk-io.c

4179

ret = btrfs_validate_write_super(fs_info, sb);

fs/btrfs/disk-io.c

4181

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/disk-io.c

4183

btrfs_err(fs_info,

fs/btrfs/disk-io.c

4193

btrfs_err(fs_info, "%d errors while writing supers",

fs/btrfs/disk-io.c

4195

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/disk-io.c

4199

btrfs_err(fs_info, "%d errors while writing supers", total_errors);

fs/btrfs/disk-io.c

4215

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/disk-io.c

4218

btrfs_err(fs_info, "%d errors while writing supers", total_errors);

fs/btrfs/disk-io.c

4225

void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

4230

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4231

radix_tree_delete(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

4235

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4237

if (unlikely(BTRFS_FS_ERROR(fs_info))) {

fs/btrfs/disk-io.c

4249

int btrfs_commit_super(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4251

mutex_lock(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

4252

btrfs_run_delayed_iputs(fs_info);

fs/btrfs/disk-io.c

4253

mutex_unlock(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

4254

wake_up_process(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

4257

down_write(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

4258

up_write(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

4260

return btrfs_commit_current_transaction(fs_info->tree_root);

fs/btrfs/disk-io.c

4263

static void warn_about_uncommitted_trans(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4273

ASSERT(test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags));

fs/btrfs/disk-io.c

4274

list_for_each_entry_safe(trans, tmp, &fs_info->trans_list, list) {

fs/btrfs/disk-io.c

4288

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

4293

if (trans == fs_info->running_transaction)

fs/btrfs/disk-io.c

4294

fs_info->running_transaction = NULL;

fs/btrfs/disk-io.c

430

btrfs_err(fs_info,

fs/btrfs/disk-io.c

4302

void __cold close_ctree(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4306

set_bit(BTRFS_FS_CLOSING_START, &fs_info->flags);

fs/btrfs/disk-io.c

4317

btrfs_wake_unfinished_drop(fs_info);

fs/btrfs/disk-io.c

4328

cancel_work_sync(&fs_info->reclaim_bgs_work);

fs/btrfs/disk-io.c

4335

kthread_park(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

4338

btrfs_qgroup_wait_for_completion(fs_info, false);

fs/btrfs/disk-io.c

4341

down(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/disk-io.c

4343

up(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/disk-io.c

4346

btrfs_pause_balance(fs_info);

fs/btrfs/disk-io.c

4348

btrfs_dev_replace_suspend_for_unmount(fs_info);

fs/btrfs/disk-io.c

4350

btrfs_scrub_cancel(fs_info);

fs/btrfs/disk-io.c

4353

wait_event(fs_info->transaction_wait,

fs/btrfs/disk-io.c

4354

(atomic_read(&fs_info->defrag_running) == 0));

fs/btrfs/disk-io.c

4357

btrfs_cleanup_defrag_inodes(fs_info);

fs/btrfs/disk-io.c

4364

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/disk-io.c

4365

btrfs_error_commit_super(fs_info);

fs/btrfs/disk-io.c

4375

btrfs_flush_workqueue(fs_info->delalloc_workers);

fs/btrfs/disk-io.c

4388

btrfs_flush_workqueue(fs_info->workers);

fs/btrfs/disk-io.c

4400

flush_workqueue(fs_info->endio_workers);

fs/btrfs/disk-io.c

4422

btrfs_flush_workqueue(fs_info->endio_write_workers);

fs/btrfs/disk-io.c

4424

btrfs_flush_workqueue(fs_info->endio_freespace_worker);

fs/btrfs/disk-io.c

4429

btrfs_run_delayed_iputs(fs_info);

fs/btrfs/disk-io.c

4431

cancel_work_sync(&fs_info->async_reclaim_work);

fs/btrfs/disk-io.c

4432

cancel_work_sync(&fs_info->async_data_reclaim_work);

fs/btrfs/disk-io.c

4433

cancel_work_sync(&fs_info->preempt_reclaim_work);

fs/btrfs/disk-io.c

4434

cancel_work_sync(&fs_info->em_shrinker_work);

fs/btrfs/disk-io.c

4443

btrfs_run_delayed_iputs(fs_info);

fs/btrfs/disk-io.c

4446

set_bit(BTRFS_FS_STATE_NO_DELAYED_IPUT, &fs_info->fs_state);

fs/btrfs/disk-io.c

4449

btrfs_discard_cleanup(fs_info);

fs/btrfs/disk-io.c

4451

if (!sb_rdonly(fs_info->sb)) {

fs/btrfs/disk-io.c

4456

btrfs_delete_unused_bgs(fs_info);

fs/btrfs/disk-io.c

4469

btrfs_flush_workqueue(fs_info->delayed_workers);

fs/btrfs/disk-io.c

4477

if (!btrfs_is_shutdown(fs_info)) {

fs/btrfs/disk-io.c

4478

ret = btrfs_commit_super(fs_info);

fs/btrfs/disk-io.c

4480

btrfs_err(fs_info, "commit super block returned %d", ret);

fs/btrfs/disk-io.c

4484

kthread_stop(fs_info->transaction_kthread);

fs/btrfs/disk-io.c

4485

kthread_stop(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

4487

ASSERT(list_empty(&fs_info->delayed_iputs));

fs/btrfs/disk-io.c

4488

set_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags);

fs/btrfs/disk-io.c

4490

if (unlikely(btrfs_check_quota_leak(fs_info))) {

fs/btrfs/disk-io.c

4492

btrfs_err(fs_info, "qgroup reserved space leaked");

fs/btrfs/disk-io.c

4495

btrfs_free_qgroup_config(fs_info);

fs/btrfs/disk-io.c

4496

ASSERT(list_empty(&fs_info->delalloc_roots));

fs/btrfs/disk-io.c

4498

if (percpu_counter_sum(&fs_info->delalloc_bytes)) {

fs/btrfs/disk-io.c

4499

btrfs_info(fs_info, "at unmount delalloc count %lld",

fs/btrfs/disk-io.c

4500

percpu_counter_sum(&fs_info->delalloc_bytes));

fs/btrfs/disk-io.c

4503

if (percpu_counter_sum(&fs_info->ordered_bytes))

fs/btrfs/disk-io.c

4504

btrfs_info(fs_info, "at unmount dio bytes count %lld",

fs/btrfs/disk-io.c

4505

percpu_counter_sum(&fs_info->ordered_bytes));

fs/btrfs/disk-io.c

4507

btrfs_sysfs_remove_mounted(fs_info);

fs/btrfs/disk-io.c

4508

btrfs_sysfs_remove_fsid(fs_info->fs_devices);

fs/btrfs/disk-io.c

4510

btrfs_put_block_group_cache(fs_info);

fs/btrfs/disk-io.c

4513

warn_about_uncommitted_trans(fs_info);

fs/btrfs/disk-io.c

4515

clear_bit(BTRFS_FS_OPEN, &fs_info->flags);

fs/btrfs/disk-io.c

4516

free_root_pointers(fs_info, true);

fs/btrfs/disk-io.c

4517

btrfs_free_fs_roots(fs_info);

fs/btrfs/disk-io.c

4523

invalidate_and_check_btree_folios(fs_info);

fs/btrfs/disk-io.c

4524

btrfs_stop_all_workers(fs_info);

fs/btrfs/disk-io.c

4533

btrfs_free_block_groups(fs_info);

fs/btrfs/disk-io.c

4535

iput(fs_info->btree_inode);

fs/btrfs/disk-io.c

4537

btrfs_mapping_tree_free(fs_info);

fs/btrfs/disk-io.c

454

btrfs_err(fs_info,

fs/btrfs/disk-io.c

4543

struct btrfs_fs_info *fs_info = buf->fs_info;

fs/btrfs/disk-io.c

4556

ASSERT(trans->transid == fs_info->generation);

fs/btrfs/disk-io.c

4558

if (unlikely(transid != fs_info->generation)) {

fs/btrfs/disk-io.c

4560

btrfs_crit(fs_info,

fs/btrfs/disk-io.c

4562

buf->start, transid, fs_info->generation);

fs/btrfs/disk-io.c

4567

static void __btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

4580

btrfs_balance_delayed_items(fs_info);

fs/btrfs/disk-io.c

4582

ret = __percpu_counter_compare(&fs_info->dirty_metadata_bytes,

fs/btrfs/disk-io.c

4584

fs_info->dirty_metadata_batch);

fs/btrfs/disk-io.c

4586

balance_dirty_pages_ratelimited(fs_info->btree_inode->i_mapping);

fs/btrfs/disk-io.c

4590

void btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4592

__btrfs_btree_balance_dirty(fs_info, 1);

fs/btrfs/disk-io.c

4595

void btrfs_btree_balance_dirty_nodelay(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4597

__btrfs_btree_balance_dirty(fs_info, 0);

fs/btrfs/disk-io.c

4600

static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4603

btrfs_cleanup_transaction(fs_info);

fs/btrfs/disk-io.c

4605

down_write(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

4606

up_write(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

4609

static void btrfs_drop_all_logs(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4615

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4616

while ((ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

4623

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4633

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4635

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4636

btrfs_free_log_root_tree(NULL, fs_info);

fs/btrfs/disk-io.c

4654

static void btrfs_destroy_all_ordered_extents(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4659

spin_lock(&fs_info->ordered_root_lock);

fs/btrfs/disk-io.c

4660

list_splice_init(&fs_info->ordered_roots, &splice);

fs/btrfs/disk-io.c

4665

&fs_info->ordered_roots);

fs/btrfs/disk-io.c

4667

spin_unlock(&fs_info->ordered_root_lock);

fs/btrfs/disk-io.c

4671

spin_lock(&fs_info->ordered_root_lock);

fs/btrfs/disk-io.c

4673

spin_unlock(&fs_info->ordered_root_lock);

fs/btrfs/disk-io.c

4681

btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);

fs/btrfs/disk-io.c

4717

static void btrfs_destroy_all_delalloc_inodes(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4722

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/disk-io.c

4723

list_splice_init(&fs_info->delalloc_roots, &splice);

fs/btrfs/disk-io.c

4729

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/disk-io.c

4734

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/disk-io.c

4736

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/disk-io.c

4739

static void btrfs_destroy_marked_extents(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

4751

eb = find_extent_buffer(fs_info, start);

fs/btrfs/disk-io.c

4752

start += fs_info->nodesize;

fs/btrfs/disk-io.c

4767

static void btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

4782

mutex_lock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/disk-io.c

4785

mutex_unlock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/disk-io.c

4791

btrfs_error_unpin_extent_range(fs_info, start, end);

fs/btrfs/disk-io.c

4792

mutex_unlock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/disk-io.c

4818

struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4842

btrfs_dec_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/disk-io.c

4864

static void btrfs_free_all_qgroup_pertrans(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4870

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4872

ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

4882

radix_tree_tag_clear(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

4887

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4892

struct btrfs_fs_info *fs_info = cur_trans->fs_info;

fs/btrfs/disk-io.c

4895

btrfs_cleanup_dirty_bgs(cur_trans, fs_info);

fs/btrfs/disk-io.c

4907

wake_up(&fs_info->transaction_blocked_wait);

fs/btrfs/disk-io.c

4910

wake_up(&fs_info->transaction_wait);

fs/btrfs/disk-io.c

4912

btrfs_destroy_marked_extents(fs_info, &cur_trans->dirty_pages,

fs/btrfs/disk-io.c

4914

btrfs_destroy_pinned_extent(fs_info, &cur_trans->pinned_extents);

fs/btrfs/disk-io.c

4920

static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4924

mutex_lock(&fs_info->transaction_kthread_mutex);

fs/btrfs/disk-io.c

4926

spin_lock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4927

while (!list_empty(&fs_info->trans_list)) {

fs/btrfs/disk-io.c

4928

t = list_first_entry(&fs_info->trans_list,

fs/btrfs/disk-io.c

4932

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4933

btrfs_wait_for_commit(fs_info, t->transid);

fs/btrfs/disk-io.c

4935

spin_lock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4938

if (t == fs_info->running_transaction) {

fs/btrfs/disk-io.c

4940

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4948

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4952

spin_lock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4953

if (t == fs_info->running_transaction)

fs/btrfs/disk-io.c

4954

fs_info->running_transaction = NULL;

fs/btrfs/disk-io.c

4956

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4959

spin_lock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4961

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4962

btrfs_destroy_all_ordered_extents(fs_info);

fs/btrfs/disk-io.c

4963

btrfs_destroy_delayed_inodes(fs_info);

fs/btrfs/disk-io.c

4964

btrfs_assert_delayed_root_empty(fs_info);

fs/btrfs/disk-io.c

4965

btrfs_destroy_all_delalloc_inodes(fs_info);

fs/btrfs/disk-io.c

4966

btrfs_drop_all_logs(fs_info);

fs/btrfs/disk-io.c

4967

btrfs_free_all_qgroup_pertrans(fs_info);

fs/btrfs/disk-io.c

4968

mutex_unlock(&fs_info->transaction_kthread_mutex);

fs/btrfs/disk-io.c

5018

btrfs_warn(root->fs_info,

fs/btrfs/disk-io.c

535

struct btrfs_fs_info *fs_info = inode_to_fs_info(mapping->host);

fs/btrfs/disk-io.c

536

struct btrfs_subpage_info *spi = fs_info->subpage_info;

fs/btrfs/disk-io.c

542

if (fs_info->sectorsize == PAGE_SIZE) {

fs/btrfs/disk-io.c

566

cur = page_start + (cur_bit << fs_info->sectorsize_bits);

fs/btrfs/disk-io.c

568

eb = find_extent_buffer(fs_info, cur);

fs/btrfs/disk-io.c

575

cur_bit += (fs_info->nodesize >> fs_info->sectorsize_bits) - 1;

fs/btrfs/disk-io.c

592

struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

596

if (btrfs_is_testing(fs_info))

fs/btrfs/disk-io.c

597

return alloc_test_extent_buffer(fs_info, bytenr);

fs/btrfs/disk-io.c

598

return alloc_extent_buffer(fs_info, bytenr, owner_root, level);

fs/btrfs/disk-io.c

608

struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,

fs/btrfs/disk-io.c

61

static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.c

616

buf = btrfs_find_create_tree_block(fs_info, bytenr, check->owner_root,

fs/btrfs/disk-io.c

62

static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.c

630

static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

639

root->fs_info = fs_info;

fs/btrfs/disk-io.c

677

if (!btrfs_is_testing(fs_info)) {

fs/btrfs/disk-io.c

678

btrfs_extent_io_tree_init(fs_info, &root->dirty_log_pages,

fs/btrfs/disk-io.c

680

btrfs_extent_io_tree_init(fs_info, &root->log_csum_range,

fs/btrfs/disk-io.c

688

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

689

list_add_tail(&root->leak_list, &fs_info->allocated_roots);

fs/btrfs/disk-io.c

69

struct btrfs_fs_info *fs_info = buf->fs_info;

fs/btrfs/disk-io.c

690

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

698

struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

702

if (!fs_info)

fs/btrfs/disk-io.c

705

root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID, GFP_KERNEL);

fs/btrfs/disk-io.c

734

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/disk-io.c

738

write_lock(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

739

tmp = rb_find_add(&root->rb_node, &fs_info->global_root_tree, global_root_cmp);

fs/btrfs/disk-io.c

740

write_unlock(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

744

btrfs_warn(fs_info, "global root %llu %llu already exists",

fs/btrfs/disk-io.c

752

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/disk-io.c

754

write_lock(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

755

rb_erase(&root->rb_node, &fs_info->global_root_tree);

fs/btrfs/disk-io.c

756

write_unlock(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

759

struct btrfs_root *btrfs_global_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

76

btrfs_csum_init(&csum, fs_info->csum_type);

fs/btrfs/disk-io.c

765

read_lock(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

766

node = rb_find(key, &fs_info->global_root_tree, global_root_key_cmp);

fs/btrfs/disk-io.c

769

read_unlock(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

774

static u64 btrfs_global_root_id(struct btrfs_fs_info *fs_info, u64 bytenr)

fs/btrfs/disk-io.c

779

if (!btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))

fs/btrfs/disk-io.c

783

block_group = btrfs_lookup_block_group(fs_info, bytenr);

fs/btrfs/disk-io.c

785

block_group = btrfs_lookup_first_block_group(fs_info, bytenr);

fs/btrfs/disk-io.c

795

struct btrfs_root *btrfs_csum_root(struct btrfs_fs_info *fs_info, u64 bytenr)

fs/btrfs/disk-io.c

800

.offset = btrfs_global_root_id(fs_info, bytenr),

fs/btrfs/disk-io.c

803

return btrfs_global_root(fs_info, &key);

fs/btrfs/disk-io.c

806

struct btrfs_root *btrfs_extent_root(struct btrfs_fs_info *fs_info, u64 bytenr)

fs/btrfs/disk-io.c

81

first_page_part = fs_info->nodesize;

fs/btrfs/disk-io.c

811

.offset = btrfs_global_root_id(fs_info, bytenr),

fs/btrfs/disk-io.c

814

return btrfs_global_root(fs_info, &key);

fs/btrfs/disk-io.c

820

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/disk-io.c

822

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/disk-io.c

832

root = btrfs_alloc_root(fs_info, objectid, GFP_KERNEL);

fs/btrfs/disk-io.c

85

first_page_part = min_t(u32, PAGE_SIZE, fs_info->nodesize);

fs/btrfs/disk-io.c

884

static struct btrfs_root *alloc_log_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

888

root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID, GFP_NOFS);

fs/btrfs/disk-io.c

928

struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

932

log_root = alloc_log_tree(fs_info);

fs/btrfs/disk-io.c

936

if (!btrfs_is_zoned(fs_info)) {

fs/btrfs/disk-io.c

945

WARN_ON(fs_info->log_root_tree);

fs/btrfs/disk-io.c

946

fs_info->log_root_tree = log_root;

fs/btrfs/disk-io.c

953

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/disk-io.c

958

log_root = alloc_log_tree(fs_info);

fs/btrfs/disk-io.c

976

fs_info->nodesize);

fs/btrfs/disk-io.c

995

struct btrfs_fs_info *fs_info = tree_root->fs_info;

fs/btrfs/disk-io.h

119

struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.h

123

struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.h

45

void btrfs_check_leaked_roots(const struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.h

46

void btrfs_init_fs_info(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.h

47

struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,

fs/btrfs/disk-io.h

50

struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.h

53

int btrfs_start_pre_rw_mount(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.h

54

int btrfs_check_super_csum(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.h

57

void __cold close_ctree(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.h

58

int btrfs_validate_super(const struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.h

60

int btrfs_check_features(struct btrfs_fs_info *fs_info, bool is_rw_mount);

fs/btrfs/disk-io.h

62

int btrfs_commit_super(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.h

65

int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.h

67

void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.h

69

struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.h

71

struct btrfs_root *btrfs_get_new_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.h

73

struct btrfs_root *btrfs_get_fs_root_commit_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.h

78

struct btrfs_root *btrfs_global_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.h

80

struct btrfs_root *btrfs_csum_root(struct btrfs_fs_info *fs_info, u64 bytenr);

fs/btrfs/disk-io.h

81

struct btrfs_root *btrfs_extent_root(struct btrfs_fs_info *fs_info, u64 bytenr);

fs/btrfs/disk-io.h

83

void btrfs_free_fs_info(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.h

84

void btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.h

85

void btrfs_btree_balance_dirty_nodelay(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.h

86

void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.h

91

struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info);

fs/btrfs/export.c

157

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/export.c

173

root = fs_info->tree_root;

fs/btrfs/export.c

216

return btrfs_get_dentry(fs_info->sb, key.objectid,

fs/btrfs/export.c

236

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/export.c

260

root = fs_info->tree_root;

fs/btrfs/export.c

82

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/export.c

89

root = btrfs_get_fs_root(fs_info, root_objectid, true);

fs/btrfs/extent-io-tree.c

104

tree->fs_info = fs_info;

fs/btrfs/extent-io-tree.c

71

btrfs_debug_rl(inode->root->fs_info,

fs/btrfs/extent-io-tree.c

95

return tree->inode->root->fs_info;

fs/btrfs/extent-io-tree.c

96

return tree->fs_info;

fs/btrfs/extent-io-tree.c

99

void btrfs_extent_io_tree_init(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-io-tree.h

113

struct btrfs_fs_info *fs_info;

fs/btrfs/extent-io-tree.h

141

void btrfs_extent_io_tree_init(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

104

struct btrfs_fs_info *fs_info, u64 bytenr,

fs/btrfs/extent-tree.c

1130

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/extent-tree.c

1149

extent_size = fs_info->nodesize;

fs/btrfs/extent-tree.c

1153

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

1193

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

1206

extent_size = fs_info->nodesize;

fs/btrfs/extent-tree.c

1210

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

122

if (metadata && !btrfs_fs_incompat(fs_info, SKINNY_METADATA)) {

fs/btrfs/extent-tree.c

123

offset = fs_info->nodesize;

fs/btrfs/extent-tree.c

1258

btrfs_crit(trans->fs_info,

fs/btrfs/extent-tree.c

1387

struct btrfs_fs_info *fs_info = dev->fs_info;

fs/btrfs/extent-tree.c

1388

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/extent-tree.c

139

extent_root = btrfs_extent_root(fs_info, bytenr);

fs/btrfs/extent-tree.c

141

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

1424

int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,

fs/btrfs/extent-tree.c

1436

btrfs_bio_counter_inc_blocked(fs_info);

fs/btrfs/extent-tree.c

1443

stripes = btrfs_map_discard(fs_info, cur, &num_bytes, &num_stripes,

fs/btrfs/extent-tree.c

1457

ASSERT(btrfs_test_opt(fs_info, DEGRADED));

fs/btrfs/extent-tree.c

1483

btrfs_bio_counter_dec(fs_info);

fs/btrfs/extent-tree.c

1493

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

1506

btrfs_ref_tree_mod(fs_info, generic_ref);

fs/btrfs/extent-tree.c

157

key.offset == fs_info->nodesize)

fs/btrfs/extent-tree.c

1582

static void free_head_ref_squota_rsv(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

1591

if (btrfs_qgroup_mode(fs_info) != BTRFS_QGROUP_MODE_SIMPLE ||

fs/btrfs/extent-tree.c

1595

btrfs_qgroup_free_refroot(fs_info, root, href->reserved_bytes,

fs/btrfs/extent-tree.c

1631

trace_run_delayed_data_ref(trans->fs_info, node);

fs/btrfs/extent-tree.c

1659

free_head_ref_squota_rsv(trans->fs_info, href);

fs/btrfs/extent-tree.c

1661

ret = btrfs_record_squota_delta(trans->fs_info, &delta);

fs/btrfs/extent-tree.c

169

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

1694

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

1707

if (!btrfs_fs_incompat(fs_info, SKINNY_METADATA))

fs/btrfs/extent-tree.c

1724

root = btrfs_extent_root(fs_info, key.objectid);

fs/btrfs/extent-tree.c

1726

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

1757

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

1769

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

1789

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

1793

trace_run_delayed_tree_ref(trans->fs_info, node);

fs/btrfs/extent-tree.c

180

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

1800

btrfs_err(trans->fs_info,

fs/btrfs/extent-tree.c

1809

.num_bytes = fs_info->nodesize,

fs/btrfs/extent-tree.c

1817

btrfs_record_squota_delta(fs_info, &delta);

fs/btrfs/extent-tree.c

1838

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

1844

free_head_ref_squota_rsv(fs_info, href);

fs/btrfs/extent-tree.c

1859

btrfs_err(fs_info, "unexpected delayed ref node type: %u", node->type);

fs/btrfs/extent-tree.c

1865

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

187

owner = btrfs_get_extent_owner_root(fs_info, leaf, path->slots[0]);

fs/btrfs/extent-tree.c

1906

u64 btrfs_cleanup_ref_head_accounting(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

1922

nr_csums = btrfs_csum_bytes_to_leaves(fs_info, head->num_bytes);

fs/btrfs/extent-tree.c

1924

btrfs_delayed_refs_rsv_release(fs_info, 0, nr_csums);

fs/btrfs/extent-tree.c

1926

ret = btrfs_calc_delayed_ref_csum_bytes(fs_info, nr_csums);

fs/btrfs/extent-tree.c

1930

free_head_ref_squota_rsv(fs_info, head);

fs/btrfs/extent-tree.c

1940

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

1949

btrfs_debug(fs_info, "run_delayed_extent_op returned %d", ret);

fs/btrfs/extent-tree.c

196

head = btrfs_find_delayed_ref_head(fs_info, delayed_refs, bytenr);

fs/btrfs/extent-tree.c

1967

btrfs_delete_ref_head(fs_info, delayed_refs, head);

fs/btrfs/extent-tree.c

1976

csum_root = btrfs_csum_root(fs_info, head->bytenr);

fs/btrfs/extent-tree.c

1978

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

1989

*bytes_released += btrfs_cleanup_ref_head_accounting(fs_info, delayed_refs, head);

fs/btrfs/extent-tree.c

1991

trace_run_delayed_ref_head(fs_info, head, 0);

fs/btrfs/extent-tree.c

2001

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

2015

btrfs_check_delayed_seq(fs_info, ref->seq)) {

fs/btrfs/extent-tree.c

2060

btrfs_delayed_refs_rsv_release(fs_info, 1, 0);

fs/btrfs/extent-tree.c

2061

*bytes_released += btrfs_calc_delayed_ref_bytes(fs_info, 1);

fs/btrfs/extent-tree.c

2074

btrfs_merge_delayed_refs(fs_info, delayed_refs, locked_ref);

fs/btrfs/extent-tree.c

2087

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

2108

locked_ref = btrfs_select_ref_head(fs_info, delayed_refs);

fs/btrfs/extent-tree.c

2132

btrfs_merge_delayed_refs(fs_info, delayed_refs, locked_ref);

fs/btrfs/extent-tree.c

2230

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

2238

if (test_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags))

fs/btrfs/extent-tree.c

2302

spin_lock(&root->fs_info->trans_lock);

fs/btrfs/extent-tree.c

2303

cur_trans = root->fs_info->running_transaction;

fs/btrfs/extent-tree.c

2306

spin_unlock(&root->fs_info->trans_lock);

fs/btrfs/extent-tree.c

2312

head = btrfs_find_delayed_ref_head(root->fs_info, delayed_refs, bytenr);

fs/btrfs/extent-tree.c

2426

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

2427

struct btrfs_root *extent_root = btrfs_extent_root(fs_info, bytenr);

fs/btrfs/extent-tree.c

2439

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

2480

if (btrfs_fs_incompat(fs_info, SIMPLE_QUOTA) && type == BTRFS_EXTENT_OWNER_REF_KEY) {

fs/btrfs/extent-tree.c

2558

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

2570

if (btrfs_is_testing(fs_info))

fs/btrfs/extent-tree.c

2624

ref.num_bytes = fs_info->nodesize;

fs/btrfs/extent-tree.c

2653

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

2658

else if (root == fs_info->chunk_root)

fs/btrfs/extent-tree.c

2660

else if (root == fs_info->remap_root)

fs/btrfs/extent-tree.c

2665

return btrfs_get_alloc_profile(fs_info, flags);

fs/btrfs/extent-tree.c

2668

static u64 first_logical_byte(struct btrfs_fs_info *fs_info)

fs/btrfs/extent-tree.c

2673

read_lock(&fs_info->block_group_cache_lock);

fs/btrfs/extent-tree.c

2675

leftmost = rb_first_cached(&fs_info->block_group_cache_tree);

fs/btrfs/extent-tree.c

2682

read_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/extent-tree.c

2712

cache = btrfs_lookup_block_group(trans->fs_info, bytenr);

fs/btrfs/extent-tree.c

2727

cache = btrfs_lookup_block_group(trans->fs_info, eb->start);

fs/btrfs/extent-tree.c

2748

static int __exclude_logged_extent(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

2754

block_group = btrfs_lookup_block_group(fs_info, start);

fs/btrfs/extent-tree.c

2770

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent-tree.c

2777

if (!btrfs_fs_incompat(fs_info, MIXED_GROUPS))

fs/btrfs/extent-tree.c

2792

ret = __exclude_logged_extent(fs_info, key.objectid, key.offset);

fs/btrfs/extent-tree.c

2811

fetch_cluster_info(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

2821

ret = &fs_info->meta_alloc_cluster;

fs/btrfs/extent-tree.c

2822

if (btrfs_test_opt(fs_info, SSD))

fs/btrfs/extent-tree.c

2827

btrfs_test_opt(fs_info, SSD_SPREAD)) {

fs/btrfs/extent-tree.c

2829

ret = &fs_info->data_alloc_cluster;

fs/btrfs/extent-tree.c

2835

static int unpin_extent_range(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

2853

cache = btrfs_lookup_block_group(fs_info, start);

fs/btrfs/extent-tree.c

2859

cluster = fetch_cluster_info(fs_info,

fs/btrfs/extent-tree.c

2899

} else if (btrfs_is_zoned(fs_info)) {

fs/btrfs/extent-tree.c

2921

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/extent-tree.c

2925

map = btrfs_get_chunk_map(fs_info, bg->start, 1);

fs/btrfs/extent-tree.c

2944

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

2949

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

2957

void btrfs_handle_fully_remapped_bgs(struct btrfs_fs_info *fs_info)

fs/btrfs/extent-tree.c

2962

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

2963

while (!list_empty(&fs_info->fully_remapped_bgs)) {

fs/btrfs/extent-tree.c

2964

bg = list_first_entry(&fs_info->fully_remapped_bgs,

fs/btrfs/extent-tree.c

2967

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

2969

btrfs_discard_extent(fs_info, bg->start, bg->length, NULL, false);

fs/btrfs/extent-tree.c

2978

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

2980

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

2985

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

2995

mutex_lock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/extent-tree.c

3001

if (btrfs_test_opt(fs_info, DISCARD_SYNC)) {

fs/btrfs/extent-tree.c

3002

ret = btrfs_discard_extent(fs_info, start,

fs/btrfs/extent-tree.c

3005

btrfs_warn(fs_info,

fs/btrfs/extent-tree.c

3013

ret = unpin_extent_range(fs_info, start, end, true);

fs/btrfs/extent-tree.c

3023

btrfs_err_rl(fs_info,

fs/btrfs/extent-tree.c

3035

mutex_unlock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/extent-tree.c

3038

mutex_lock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/extent-tree.c

3049

mutex_unlock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/extent-tree.c

3052

if (btrfs_test_opt(fs_info, DISCARD_ASYNC)) {

fs/btrfs/extent-tree.c

3053

btrfs_discard_calc_delay(&fs_info->discard_ctl);

fs/btrfs/extent-tree.c

3054

btrfs_discard_schedule_work(&fs_info->discard_ctl, true);

fs/btrfs/extent-tree.c

3066

ret = btrfs_discard_extent(fs_info, block_group->start,

fs/btrfs/extent-tree.c

3074

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

3076

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

3083

btrfs_warn(fs_info,

fs/btrfs/extent-tree.c

3106

u64 btrfs_get_extent_owner_root(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

3116

if (!btrfs_fs_incompat(fs_info, SIMPLE_QUOTA))

fs/btrfs/extent-tree.c

3160

csum_root = btrfs_csum_root(trans->fs_info, bytenr);

fs/btrfs/extent-tree.c

3164

btrfs_err(trans->fs_info,

fs/btrfs/extent-tree.c

3183

ret = btrfs_record_squota_delta(trans->fs_info, delta);

fs/btrfs/extent-tree.c

3209

btrfs_crit(trans->fs_info, fmt, ##args); \

fs/btrfs/extent-tree.c

3276

struct btrfs_fs_info *info = trans->fs_info;

fs/btrfs/extent-tree.c

3437

btrfs_err(trans->fs_info,

fs/btrfs/extent-tree.c

349

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent-tree.c

354

ASSERT(btrfs_fs_incompat(fs_info, SIMPLE_QUOTA));

fs/btrfs/extent-tree.c

3547

delta.root = btrfs_get_extent_owner_root(trans->fs_info,

fs/btrfs/extent-tree.c

3574

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

3581

head = btrfs_find_delayed_ref_head(fs_info, delayed_refs, bytenr);

fs/btrfs/extent-tree.c

3599

btrfs_delete_ref_head(fs_info, delayed_refs, head);

fs/btrfs/extent-tree.c

3609

btrfs_cleanup_ref_head_accounting(fs_info, delayed_refs, head);

fs/btrfs/extent-tree.c

3626

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

3649

btrfs_ref_tree_mod(fs_info, &generic_ref);

fs/btrfs/extent-tree.c

366

ASSERT(fs_info);

fs/btrfs/extent-tree.c

3667

bg = btrfs_lookup_block_group(fs_info, buf->start);

fs/btrfs/extent-tree.c

3692

if (test_bit(BTRFS_FS_TREE_MOD_LOG_USERS, &fs_info->flags)

fs/btrfs/extent-tree.c

3693

|| btrfs_is_zoned(fs_info)) {

fs/btrfs/extent-tree.c

3704

trace_btrfs_reserved_extent_free(fs_info, buf->start, buf->len);

fs/btrfs/extent-tree.c

371

if (offset && IS_ALIGNED(offset, fs_info->sectorsize))

fs/btrfs/extent-tree.c

3712

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

3715

if (btrfs_is_testing(fs_info))

fs/btrfs/extent-tree.c

3732

btrfs_ref_tree_mod(fs_info, ref);

fs/btrfs/extent-tree.c

378

ASSERT(fs_info);

fs/btrfs/extent-tree.c

384

IS_ALIGNED(offset, fs_info->sectorsize))

fs/btrfs/extent-tree.c

395

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

4033

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/extent-tree.c

4044

ASSERT(btrfs_is_zoned(block_group->fs_info));

fs/btrfs/extent-tree.c

4050

spin_lock(&fs_info->treelog_bg_lock);

fs/btrfs/extent-tree.c

4051

log_bytenr = fs_info->treelog_bg;

fs/btrfs/extent-tree.c

4055

spin_unlock(&fs_info->treelog_bg_lock);

fs/btrfs/extent-tree.c

4063

spin_lock(&fs_info->relocation_bg_lock);

fs/btrfs/extent-tree.c

4064

data_reloc_bytenr = fs_info->data_reloc_bg;

fs/btrfs/extent-tree.c

4069

spin_unlock(&fs_info->relocation_bg_lock);

fs/btrfs/extent-tree.c

4095

spin_lock(&fs_info->treelog_bg_lock);

fs/btrfs/extent-tree.c

4096

spin_lock(&fs_info->relocation_bg_lock);

fs/btrfs/extent-tree.c

4102

block_group->start == fs_info->treelog_bg ||

fs/btrfs/extent-tree.c

4103

fs_info->treelog_bg == 0);

fs/btrfs/extent-tree.c

4105

block_group->start == fs_info->data_reloc_bg ||

fs/btrfs/extent-tree.c

4106

fs_info->data_reloc_bg == 0);

fs/btrfs/extent-tree.c

4119

if (ffe_ctl->for_treelog && !fs_info->treelog_bg &&

fs/btrfs/extent-tree.c

4129

if (ffe_ctl->for_data_reloc && !fs_info->data_reloc_bg &&

fs/btrfs/extent-tree.c

4150

if (ffe_ctl->for_treelog && !fs_info->treelog_bg)

fs/btrfs/extent-tree.c

4151

fs_info->treelog_bg = block_group->start;

fs/btrfs/extent-tree.c

4154

if (!fs_info->data_reloc_bg)

fs/btrfs/extent-tree.c

4155

fs_info->data_reloc_bg = block_group->start;

fs/btrfs/extent-tree.c

4189

fs_info->treelog_bg = 0;

fs/btrfs/extent-tree.c

4191

fs_info->data_reloc_bg = 0;

fs/btrfs/extent-tree.c

4192

spin_unlock(&fs_info->relocation_bg_lock);

fs/btrfs/extent-tree.c

4193

spin_unlock(&fs_info->treelog_bg_lock);

fs/btrfs/extent-tree.c

4259

static int can_allocate_chunk_zoned(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

4267

if (btrfs_can_activate_zone(fs_info->fs_devices, ffe_ctl->flags))

fs/btrfs/extent-tree.c

4278

int ret = btrfs_zone_finish_one_bg(fs_info);

fs/btrfs/extent-tree.c

4312

static int can_allocate_chunk(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

4319

return can_allocate_chunk_zoned(fs_info, ffe_ctl);

fs/btrfs/extent-tree.c

4330

static int find_free_extent_update_loop(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

4336

struct btrfs_root *root = fs_info->chunk_root;

fs/btrfs/extent-tree.c

4374

ret = can_allocate_chunk(fs_info, ffe_ctl);

fs/btrfs/extent-tree.c

4424

static int prepare_allocation_clustered(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

443

struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr);

fs/btrfs/extent-tree.c

4452

ffe_ctl->last_ptr = fetch_cluster_info(fs_info, space_info,

fs/btrfs/extent-tree.c

4475

static int prepare_allocation_zoned(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

4482

spin_lock(&fs_info->treelog_bg_lock);

fs/btrfs/extent-tree.c

4483

if (fs_info->treelog_bg)

fs/btrfs/extent-tree.c

4484

ffe_ctl->hint_byte = fs_info->treelog_bg;

fs/btrfs/extent-tree.c

4485

spin_unlock(&fs_info->treelog_bg_lock);

fs/btrfs/extent-tree.c

4490

spin_lock(&fs_info->relocation_bg_lock);

fs/btrfs/extent-tree.c

4491

if (fs_info->data_reloc_bg)

fs/btrfs/extent-tree.c

4492

ffe_ctl->hint_byte = fs_info->data_reloc_bg;

fs/btrfs/extent-tree.c

4493

spin_unlock(&fs_info->relocation_bg_lock);

fs/btrfs/extent-tree.c

4500

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/extent-tree.c

4501

list_for_each_entry(block_group, &fs_info->zone_active_bgs, active_bg_list) {

fs/btrfs/extent-tree.c

4515

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/extent-tree.c

452

btrfs_err(trans->fs_info,

fs/btrfs/extent-tree.c

4520

static int prepare_allocation(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

4527

return prepare_allocation_clustered(fs_info, ffe_ctl,

fs/btrfs/extent-tree.c

4530

return prepare_allocation_zoned(fs_info, ffe_ctl, space_info);

fs/btrfs/extent-tree.c

4565

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

4572

WARN_ON(ffe_ctl->num_bytes < fs_info->sectorsize);

fs/btrfs/extent-tree.c

4591

if (btrfs_is_zoned(fs_info))

fs/btrfs/extent-tree.c

4600

space_info = btrfs_find_space_info(fs_info, ffe_ctl->flags);

fs/btrfs/extent-tree.c

4601

if (btrfs_is_zoned(fs_info) && space_info) {

fs/btrfs/extent-tree.c

4614

btrfs_err(fs_info, "no space info for %llu, tree-log %d, relocation %d",

fs/btrfs/extent-tree.c

4619

ret = prepare_allocation(fs_info, ffe_ctl, space_info, ins);

fs/btrfs/extent-tree.c

4624

first_logical_byte(fs_info));

fs/btrfs/extent-tree.c

4627

block_group = btrfs_lookup_block_group(fs_info,

fs/btrfs/extent-tree.c

4760

fs_info->stripesize);

fs/btrfs/extent-tree.c

4810

ret = find_free_extent_update_loop(fs_info, ins, ffe_ctl, space_info,

fs/btrfs/extent-tree.c

4882

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

4892

WARN_ON(num_bytes < fs_info->sectorsize);

fs/btrfs/extent-tree.c

4906

btrfs_dec_block_group_reservations(fs_info, ins->objectid);

fs/btrfs/extent-tree.c

4911

fs_info->sectorsize);

fs/btrfs/extent-tree.c

4917

} else if (btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {

fs/btrfs/extent-tree.c

4920

sinfo = btrfs_find_space_info(fs_info, flags);

fs/btrfs/extent-tree.c

4921

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

4932

int btrfs_free_reserved_extent(struct btrfs_fs_info *fs_info, u64 start, u64 len,

fs/btrfs/extent-tree.c

4937

cache = btrfs_lookup_block_group(fs_info, start);

fs/btrfs/extent-tree.c

4939

btrfs_err(fs_info, "Unable to find block group for %llu",

fs/btrfs/extent-tree.c

4946

trace_btrfs_reserved_extent_free(fs_info, start, len);

fs/btrfs/extent-tree.c

4958

cache = btrfs_lookup_block_group(trans->fs_info, eb->start);

fs/btrfs/extent-tree.c

4960

btrfs_err(trans->fs_info, "unable to find block group for %llu",

fs/btrfs/extent-tree.c

4973

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

4983

btrfs_err(fs_info, "update block group failed for %llu %llu",

fs/btrfs/extent-tree.c

4988

trace_btrfs_reserved_extent_alloc(fs_info, bytenr, num_bytes);

fs/btrfs/extent-tree.c

4997

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

5007

const bool simple_quota = (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE);

fs/btrfs/extent-tree.c

5019

extent_root = btrfs_extent_root(fs_info, ins->objectid);

fs/btrfs/extent-tree.c

5021

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

5077

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

5090

bool skinny_metadata = btrfs_fs_incompat(fs_info, SKINNY_METADATA);

fs/btrfs/extent-tree.c

5106

extent_root = btrfs_extent_root(fs_info, extent_key.objectid);

fs/btrfs/extent-tree.c

5108

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

5155

return alloc_reserved_extent(trans, node->bytenr, fs_info->nodesize);

fs/btrfs/extent-tree.c

5177

btrfs_ref_tree_mod(root->fs_info, &generic_ref);

fs/btrfs/extent-tree.c

5191

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

5207

if (!btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {

fs/btrfs/extent-tree.c

5208

ret = __exclude_logged_extent(fs_info, ins->objectid,

fs/btrfs/extent-tree.c

5214

block_group = btrfs_lookup_block_group(fs_info, ins->objectid);

fs/btrfs/extent-tree.c

522

struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr);

fs/btrfs/extent-tree.c

5230

ret = btrfs_record_squota_delta(fs_info, &delta);

fs/btrfs/extent-tree.c

5243

btrfs_err_rl(eb->fs_info,

fs/btrfs/extent-tree.c

5262

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

5266

buf = btrfs_find_create_tree_block(fs_info, bytenr, owner, level);

fs/btrfs/extent-tree.c

5312

write_extent_buffer_fsid(buf, fs_info->fs_devices->metadata_uuid);

fs/btrfs/extent-tree.c

5313

write_extent_buffer_chunk_tree_uuid(buf, fs_info->chunk_tree_uuid);

fs/btrfs/extent-tree.c

532

btrfs_err(trans->fs_info,

fs/btrfs/extent-tree.c

5350

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

5356

u32 blocksize = fs_info->nodesize;

fs/btrfs/extent-tree.c

5357

bool skinny_metadata = btrfs_fs_incompat(fs_info, SKINNY_METADATA);

fs/btrfs/extent-tree.c

5361

if (btrfs_is_testing(fs_info)) {

fs/btrfs/extent-tree.c

5424

btrfs_ref_tree_mod(fs_info, &generic_ref);

fs/btrfs/extent-tree.c

5437

btrfs_free_reserved_extent(fs_info, ins.objectid, ins.offset, false);

fs/btrfs/extent-tree.c

5439

btrfs_unuse_block_rsv(fs_info, block_rsv, blocksize);

fs/btrfs/extent-tree.c

5554

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

5571

BTRFS_NODEPTRS_PER_BLOCK(fs_info));

fs/btrfs/extent-tree.c

5593

ret = btrfs_lookup_extent_info(trans, fs_info, bytenr,

fs/btrfs/extent-tree.c

5632

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

5649

ret = btrfs_lookup_extent_info(trans, fs_info,

fs/btrfs/extent-tree.c

5657

btrfs_err(fs_info, "bytenr %llu has 0 references, expect > 0",

fs/btrfs/extent-tree.c

5726

root->fs_info->nodesize, parent,

fs/btrfs/extent-tree.c

5743

head = btrfs_find_delayed_ref_head(root->fs_info, delayed_refs, bytenr);

fs/btrfs/extent-tree.c

5834

.num_bytes = root->fs_info->nodesize,

fs/btrfs/extent-tree.c

5850

btrfs_err(root->fs_info, "mismatched block owner");

fs/btrfs/extent-tree.c

5882

btrfs_err_rl(root->fs_info,

fs/btrfs/extent-tree.c

5919

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

5942

next = btrfs_find_create_tree_block(fs_info, bytenr, btrfs_root_id(root),

fs/btrfs/extent-tree.c

5949

ret = btrfs_lookup_extent_info(trans, fs_info, bytenr, level - 1, 1,

fs/btrfs/extent-tree.c

5957

btrfs_err(fs_info, "bytenr %llu has 0 references, expect > 0",

fs/btrfs/extent-tree.c

5986

btrfs_err(root->fs_info, "mismatched level");

fs/btrfs/extent-tree.c

6030

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

6059

ret = btrfs_lookup_extent_info(trans, fs_info,

fs/btrfs/extent-tree.c

6071

btrfs_err(fs_info, "bytenr %llu has 0 references, expect > 0",

fs/btrfs/extent-tree.c

6098

btrfs_err_rl(fs_info,

fs/btrfs/extent-tree.c

6135

btrfs_err_rl(fs_info, "unexpected tree owner, have %llu expect %llu",

fs/btrfs/extent-tree.c

624

btrfs_err(trans->fs_info,

fs/btrfs/extent-tree.c

6261

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

6264

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/extent-tree.c

6274

btrfs_debug(fs_info, "Drop subvolume %llu", btrfs_root_id(root));

fs/btrfs/extent-tree.c

6354

ret = btrfs_lookup_extent_info(trans, fs_info,

fs/btrfs/extent-tree.c

6379

wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);

fs/btrfs/extent-tree.c

6413

(!for_reloc && btrfs_need_cleaner_sleep(fs_info))) {

fs/btrfs/extent-tree.c

6423

btrfs_set_last_root_drop_gen(fs_info, trans->transid);

fs/btrfs/extent-tree.c

6426

if (!for_reloc && btrfs_need_cleaner_sleep(fs_info)) {

fs/btrfs/extent-tree.c

6427

btrfs_debug(fs_info,

fs/btrfs/extent-tree.c

6491

btrfs_set_last_root_drop_gen(fs_info, trans->transid);

fs/btrfs/extent-tree.c

6498

ret = btrfs_qgroup_cleanup_dropped_subvolume(fs_info, rootid);

fs/btrfs/extent-tree.c

6500

btrfs_warn_rl(fs_info,

fs/btrfs/extent-tree.c

6510

btrfs_maybe_wake_unfinished_drop(fs_info);

fs/btrfs/extent-tree.c

6535

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

6571

wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);

fs/btrfs/extent-tree.c

6593

void btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info, u64 start, u64 end)

fs/btrfs/extent-tree.c

6595

unpin_extent_range(fs_info, start, end, false);

fs/btrfs/extent-tree.c

6646

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/extent-tree.c

6652

ret = mutex_lock_interruptible(&fs_info->chunk_mutex);

fs/btrfs/extent-tree.c

6665

btrfs_warn(fs_info,

fs/btrfs/extent-tree.c

6670

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/extent-tree.c

6690

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/extent-tree.c

6700

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/extent-tree.c

6725

static int btrfs_trim_free_extents(struct btrfs_fs_info *fs_info, u64 *trimmed,

fs/btrfs/extent-tree.c

6730

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/extent-tree.c

6794

btrfs_warn(fs_info,

fs/btrfs/extent-tree.c

6850

int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range)

fs/btrfs/extent-tree.c

6875

cache = btrfs_lookup_first_block_group(fs_info, range->start);

fs/btrfs/extent-tree.c

691

struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr);

fs/btrfs/extent-tree.c

6916

btrfs_warn(fs_info,

fs/btrfs/extent-tree.c

6923

ret = btrfs_trim_free_extents(fs_info, &group_trimmed, &dev_failed, &dev_ret);

fs/btrfs/extent-tree.c

6927

btrfs_warn(fs_info,

fs/btrfs/extent-tree.c

696

btrfs_err(trans->fs_info,

fs/btrfs/extent-tree.c

72

int btrfs_lookup_data_extent(struct btrfs_fs_info *fs_info, u64 start, u64 len)

fs/btrfs/extent-tree.c

721

struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr);

fs/btrfs/extent-tree.c

726

btrfs_err(trans->fs_info,

fs/btrfs/extent-tree.c

74

struct btrfs_root *root = btrfs_extent_root(fs_info, start);

fs/btrfs/extent-tree.c

79

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

804

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

805

struct btrfs_root *root = btrfs_extent_root(fs_info, bytenr);

fs/btrfs/extent-tree.c

818

bool skinny_metadata = btrfs_fs_incompat(fs_info, SKINNY_METADATA);

fs/btrfs/extent-tree.c

822

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

881

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

893

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

921

ASSERT(btrfs_fs_incompat(fs_info, SIMPLE_QUOTA));

fs/btrfs/extent-tree.c

973

btrfs_crit(fs_info,

fs/btrfs/extent-tree.h

105

u64 btrfs_cleanup_ref_head_accounting(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.h

108

int btrfs_lookup_data_extent(struct btrfs_fs_info *fs_info, u64 start, u64 len);

fs/btrfs/extent-tree.h

110

struct btrfs_fs_info *fs_info, u64 bytenr,

fs/btrfs/extent-tree.h

149

u64 btrfs_get_extent_owner_root(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.h

151

int btrfs_free_reserved_extent(struct btrfs_fs_info *fs_info, u64 start, u64 len,

fs/btrfs/extent-tree.h

162

void btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info, u64 start, u64 end);

fs/btrfs/extent-tree.h

163

int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,

fs/btrfs/extent-tree.h

165

int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range);

fs/btrfs/extent-tree.h

166

void btrfs_handle_fully_remapped_bgs(struct btrfs_fs_info *fs_info);

fs/btrfs/extent_io.c

1036

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/extent_io.c

1044

const size_t blocksize = fs_info->sectorsize;

fs/btrfs/extent_io.c

1065

begin_folio_read(fs_info, folio);

fs/btrfs/extent_io.c

1075

ASSERT(IS_ALIGNED(cur, fs_info->sectorsize));

fs/btrfs/extent_io.c

1081

if (btrfs_folio_test_uptodate(fs_info, folio, cur, blocksize)) {

fs/btrfs/extent_io.c

1109

!btrfs_is_subpage(fs_info, folio) &&

fs/btrfs/extent_io.c

1213

const struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/extent_io.c

1215

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/extent_io.c

1255

if (btrfs_folio_test_dirty(fs_info, folio, cur, blocksize)) {

fs/btrfs/extent_io.c

1264

ASSERT(btrfs_folio_test_dirty(fs_info, folio, cur, range_len));

fs/btrfs/extent_io.c

1277

if (btrfs_folio_test_uptodate(fs_info, folio, cur, blocksize)) {

fs/btrfs/extent_io.c

1285

ASSERT(btrfs_folio_test_uptodate(fs_info, folio, cur, range_len));

fs/btrfs/extent_io.c

1407

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

1413

start_bit = (start - folio_start) >> fs_info->sectorsize_bits;

fs/btrfs/extent_io.c

1414

nbits = len >> fs_info->sectorsize_bits;

fs/btrfs/extent_io.c

1423

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

1425

const unsigned int bitmap_size = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/extent_io.c

1432

start_bit = (start - folio_start) >> fs_info->sectorsize_bits;

fs/btrfs/extent_io.c

1437

*found_start = folio_start + (first_set << fs_info->sectorsize_bits);

fs/btrfs/extent_io.c

1439

*found_len = (first_zero - first_set) << fs_info->sectorsize_bits;

fs/btrfs/extent_io.c

1462

struct btrfs_fs_info *fs_info = inode_to_fs_info(&inode->vfs_inode);

fs/btrfs/extent_io.c

1464

const bool is_subpage = btrfs_is_subpage(fs_info, folio);

fs/btrfs/extent_io.c

1467

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/extent_io.c

1493

btrfs_copy_subpage_dirty_bitmap(fs_info, folio, bio_ctrl->submit_bitmap);

fs/btrfs/extent_io.c

1497

u64 start = page_start + (start_bit << fs_info->sectorsize_bits);

fs/btrfs/extent_io.c

1498

u32 len = (end_bit - start_bit) << fs_info->sectorsize_bits;

fs/btrfs/extent_io.c

1500

btrfs_folio_set_lock(fs_info, folio, start, len);

fs/btrfs/extent_io.c

1565

btrfs_err_rl(fs_info,

fs/btrfs/extent_io.c

1593

fs_info->sectorsize_bits;

fs/btrfs/extent_io.c

1595

page_start) >> fs_info->sectorsize_bits;

fs/btrfs/extent_io.c

1614

fs_info->sectorsize_bits,

fs/btrfs/extent_io.c

1619

u64 start = page_start + (start_bit << fs_info->sectorsize_bits);

fs/btrfs/extent_io.c

1620

u32 len = (end_bit - start_bit) << fs_info->sectorsize_bits;

fs/btrfs/extent_io.c

1670

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/extent_io.c

1676

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/extent_io.c

1698

btrfs_folio_clear_dirty(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1699

btrfs_folio_set_writeback(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1700

btrfs_folio_clear_writeback(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1706

btrfs_mark_ordered_io_finished(inode, filepos, fs_info->sectorsize,

fs/btrfs/extent_io.c

173

bio_ctrl->generation < btrfs_get_fs_generation(bbio->inode->root->fs_info));

fs/btrfs/extent_io.c

1733

btrfs_folio_clear_dirty(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1734

btrfs_folio_set_writeback(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1746

btrfs_folio_clear_writeback(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1747

btrfs_mark_ordered_io_finished(inode, filepos, fs_info->sectorsize,

fs/btrfs/extent_io.c

1768

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/extent_io.c

1774

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/extent_io.c

1786

(start - folio_start) >> fs_info->sectorsize_bits);

fs/btrfs/extent_io.c

1789

(end - folio_start) >> fs_info->sectorsize_bits,

fs/btrfs/extent_io.c

1790

(folio_end - end) >> fs_info->sectorsize_bits);

fs/btrfs/extent_io.c

1795

cur = folio_pos(folio) + (bit << fs_info->sectorsize_bits);

fs/btrfs/extent_io.c

1801

fs_info->sectorsize);

fs/btrfs/extent_io.c

1814

btrfs_mark_ordered_io_finished(inode, cur, fs_info->sectorsize, true);

fs/btrfs/extent_io.c

1823

btrfs_folio_clear_dirty(fs_info, folio, cur, fs_info->sectorsize);

fs/btrfs/extent_io.c

1847

btrfs_folio_set_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

1848

btrfs_folio_clear_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

1853

static void bio_ctrl_init_submit_bitmap(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

1857

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/extent_io.c

1884

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/extent_io.c

1889

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/extent_io.c

1906

bio_ctrl_init_submit_bitmap(fs_info, folio, bio_ctrl);

fs/btrfs/extent_io.c

1918

btrfs_err_rl(fs_info,

fs/btrfs/extent_io.c

1941

btrfs_err_rl(fs_info,

fs/btrfs/extent_io.c

1956

btrfs_folio_end_lock_bitmap(fs_info, folio, bio_ctrl->submit_bitmap);

fs/btrfs/extent_io.c

1971

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

1992

XA_STATE(xas, &fs_info->buffer_tree, eb->start >> fs_info->nodesize_bits);

fs/btrfs/extent_io.c

2006

percpu_counter_add_batch(&fs_info->dirty_metadata_bytes,

fs/btrfs/extent_io.c

2008

fs_info->dirty_metadata_batch);

fs/btrfs/extent_io.c

2019

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

2035

mapping_set_error(eb->fs_info->btree_inode->i_mapping, -EIO);

fs/btrfs/extent_io.c

2077

set_bit(BTRFS_FS_BTREE_ERR, &fs_info->flags);

fs/btrfs/extent_io.c

2080

set_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags);

fs/btrfs/extent_io.c

2083

set_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags);

fs/btrfs/extent_io.c

2092

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

2093

XA_STATE(xas, &fs_info->buffer_tree, eb->start >> fs_info->nodesize_bits);

fs/btrfs/extent_io.c

2104

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

2105

XA_STATE(xas, &fs_info->buffer_tree, eb->start >> fs_info->nodesize_bits);

fs/btrfs/extent_io.c

2114

static void buffer_tree_tag_for_writeback(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

2117

XA_STATE(xas, &fs_info->buffer_tree, start);

fs/btrfs/extent_io.c

2194

static unsigned int buffer_tree_get_ebs_tag(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

2199

XA_STATE(xas, &fs_info->buffer_tree, *start);

fs/btrfs/extent_io.c

2205

*start = ((eb->start + eb->len) >> fs_info->nodesize_bits);

fs/btrfs/extent_io.c

2224

struct btrfs_fs_info *fs_info, u64 start)

fs/btrfs/extent_io.c

2227

unsigned long index = (start >> fs_info->nodesize_bits);

fs/btrfs/extent_io.c

2230

eb = xa_load(&fs_info->buffer_tree, index);

fs/btrfs/extent_io.c

2275

end += BTRFS_LEAF_DATA_SIZE(eb->fs_info);

fs/btrfs/extent_io.c

2285

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

2292

BTRFS_I(fs_info->btree_inode), eb->start,

fs/btrfs/extent_io.c

2295

bio_set_dev(&bbio->bio, fs_info->fs_devices->latest_dev->bdev);

fs/btrfs/extent_io.c

2317

if (unlikely(BTRFS_FS_ERROR(fs_info))) {

fs/btrfs/extent_io.c

2318

btrfs_bio_end_io(bbio, errno_to_blk_status(BTRFS_FS_ERROR(fs_info)));

fs/btrfs/extent_io.c

2333

void btrfs_btree_wait_writeback_range(struct btrfs_fs_info *fs_info, u64 start,

fs/btrfs/extent_io.c

2337

unsigned long start_index = (start >> fs_info->nodesize_bits);

fs/btrfs/extent_io.c

2338

unsigned long end_index = (end >> fs_info->nodesize_bits);

fs/btrfs/extent_io.c

2345

nr_ebs = buffer_tree_get_ebs_tag(fs_info, &start_index, end_index,

fs/btrfs/extent_io.c

2360

struct btrfs_fs_info *fs_info = inode_to_fs_info(mapping->host);

fs/btrfs/extent_io.c

2373

index = ((mapping->writeback_index << PAGE_SHIFT) >> fs_info->nodesize_bits);

fs/btrfs/extent_io.c

2382

index = (wbc->range_start >> fs_info->nodesize_bits);

fs/btrfs/extent_io.c

2383

end = (wbc->range_end >> fs_info->nodesize_bits);

fs/btrfs/extent_io.c

2391

btrfs_zoned_meta_io_lock(fs_info);

fs/btrfs/extent_io.c

2394

buffer_tree_tag_for_writeback(fs_info, index, end);

fs/btrfs/extent_io.c

2396

(nr_ebs = buffer_tree_get_ebs_tag(fs_info, &index, end, tag, &batch))) {

fs/btrfs/extent_io.c

2402

ret = btrfs_check_meta_write_pointer(eb->fs_info, &ctx);

fs/btrfs/extent_io.c

2444

if (unlikely(!ret && BTRFS_FS_ERROR(fs_info)))

fs/btrfs/extent_io.c

2449

btrfs_zoned_meta_io_unlock(fs_info);

fs/btrfs/extent_io.c

245

static void process_one_folio(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

255

btrfs_folio_clamp_clear_dirty(fs_info, folio, start, len);

fs/btrfs/extent_io.c

256

btrfs_folio_clamp_set_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

259

btrfs_folio_clamp_clear_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

262

btrfs_folio_end_lock(fs_info, folio, start, len);

fs/btrfs/extent_io.c

2647

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/extent_io.c

2648

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/extent_io.c

269

struct btrfs_fs_info *fs_info = inode_to_fs_info(mapping->host);

fs/btrfs/extent_io.c

2692

bio_ctrl_init_submit_bitmap(fs_info, folio, &bio_ctrl);

fs/btrfs/extent_io.c

2700

btrfs_folio_end_lock(fs_info, folio, cur, cur_len);

fs/btrfs/extent_io.c

2820

const u64 cur_gen = btrfs_get_fs_generation(inode->root->fs_info);

fs/btrfs/extent_io.c

284

process_one_folio(fs_info, folio, locked_folio,

fs/btrfs/extent_io.c

2905

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

2922

if (!btrfs_meta_is_subpage(fs_info)) {

fs/btrfs/extent_io.c

2947

btrfs_detach_folio_state(fs_info, folio, BTRFS_SUBPAGE_METADATA);

fs/btrfs/extent_io.c

2951

btrfs_folio_dec_eb_refs(fs_info, folio);

fs/btrfs/extent_io.c

2958

btrfs_detach_folio_state(fs_info, folio, BTRFS_SUBPAGE_METADATA);

fs/btrfs/extent_io.c

3001

unsigned long index = eb->start >> trans->fs_info->nodesize_bits;

fs/btrfs/extent_io.c

3046

static struct extent_buffer *__alloc_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

3053

eb->len = fs_info->nodesize;

fs/btrfs/extent_io.c

3054

eb->fs_info = fs_info;

fs/btrfs/extent_io.c

306

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/extent_io.c

3092

new = __alloc_extent_buffer(src->fs_info, src->start);

fs/btrfs/extent_io.c

3134

struct extent_buffer *alloc_dummy_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

3140

eb = __alloc_extent_buffer(fs_info, start);

fs/btrfs/extent_io.c

3212

struct extent_buffer *find_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

3217

eb = find_extent_buffer_nolock(fs_info, start);

fs/btrfs/extent_io.c

3241

struct extent_buffer *alloc_test_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

3248

eb = find_extent_buffer(fs_info, start);

fs/btrfs/extent_io.c

3251

eb = alloc_dummy_extent_buffer(fs_info, start);

fs/btrfs/extent_io.c

3254

eb->fs_info = fs_info;

fs/btrfs/extent_io.c

3256

xa_lock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3257

exists = __xa_cmpxchg(&fs_info->buffer_tree, start >> fs_info->nodesize_bits,

fs/btrfs/extent_io.c

3261

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3268

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3271

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3275

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3285

static struct extent_buffer *grab_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

3297

if (btrfs_meta_is_subpage(fs_info))

fs/btrfs/extent_io.c

3322

static bool check_eb_alignment(struct btrfs_fs_info *fs_info, u64 start)

fs/btrfs/extent_io.c

3324

const u32 nodesize = fs_info->nodesize;

fs/btrfs/extent_io.c

3326

if (unlikely(!IS_ALIGNED(start, fs_info->sectorsize))) {

fs/btrfs/extent_io.c

3327

btrfs_err(fs_info, "bad tree block start %llu", start);

fs/btrfs/extent_io.c

3332

btrfs_err(fs_info,

fs/btrfs/extent_io.c

3338

btrfs_err(fs_info,

fs/btrfs/extent_io.c

3344

!test_and_set_bit(BTRFS_FS_UNALIGNED_TREE_BLOCK, &fs_info->flags))) {

fs/btrfs/extent_io.c

3345

btrfs_warn(fs_info,

fs/btrfs/extent_io.c

3365

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

3366

struct address_space *mapping = fs_info->btree_inode->i_mapping;

fs/btrfs/extent_io.c

337

btrfs_folio_set_lock(fs_info, folio, range_start, range_len);

fs/btrfs/extent_io.c

3399

if (existing_folio && btrfs_meta_is_subpage(fs_info)) {

fs/btrfs/extent_io.c

3406

existing_eb = grab_extent_buffer(fs_info, existing_folio);

fs/btrfs/extent_io.c

3433

btrfs_folio_inc_eb_refs(fs_info, eb->folios[i]);

fs/btrfs/extent_io.c

3438

struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

3450

if (check_eb_alignment(fs_info, start))

fs/btrfs/extent_io.c

3455

btrfs_err_rl(fs_info,

fs/btrfs/extent_io.c

3457

btrfs_err_32bit_limit(fs_info);

fs/btrfs/extent_io.c

3461

btrfs_warn_32bit_limit(fs_info);

fs/btrfs/extent_io.c

3464

eb = find_extent_buffer(fs_info, start);

fs/btrfs/extent_io.c

3468

eb = __alloc_extent_buffer(fs_info, start);

fs/btrfs/extent_io.c

3488

if (btrfs_meta_is_subpage(fs_info)) {

fs/btrfs/extent_io.c

3489

prealloc = btrfs_alloc_folio_state(fs_info, PAGE_SIZE, BTRFS_SUBPAGE_METADATA);

fs/btrfs/extent_io.c

3576

xa_lock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3577

existing_eb = __xa_cmpxchg(&fs_info->buffer_tree,

fs/btrfs/extent_io.c

3578

start >> fs_info->nodesize_bits, NULL, eb,

fs/btrfs/extent_io.c

3582

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3587

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3590

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3593

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3662

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

3680

xa_cmpxchg_irq(&fs_info->buffer_tree,

fs/btrfs/extent_io.c

3681

eb->start >> fs_info->nodesize_bits, eb, NULL,

fs/btrfs/extent_io.c

373

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/extent_io.c

3752

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

3768

if (btrfs_is_zoned(fs_info) && test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags)) {

fs/btrfs/extent_io.c

377

u64 max_bytes = fs_info->max_extent_size;

fs/btrfs/extent_io.c

3777

percpu_counter_add_batch(&fs_info->dirty_metadata_bytes, -(s64)eb->len,

fs/btrfs/extent_io.c

3778

fs_info->dirty_metadata_batch);

fs/btrfs/extent_io.c

3808

bool subpage = btrfs_meta_is_subpage(eb->fs_info);

fs/btrfs/extent_io.c

3828

percpu_counter_add_batch(&eb->fs_info->dirty_metadata_bytes,

fs/btrfs/extent_io.c

3830

eb->fs_info->dirty_metadata_batch);

fs/btrfs/extent_io.c

3897

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

3948

REQ_OP_READ | REQ_META, BTRFS_I(fs_info->btree_inode),

fs/btrfs/extent_io.c

3984

btrfs_warn(eb->fs_info,

fs/btrfs/extent_io.c

400

ASSERT(max_bytes >= fs_info->sectorsize);

fs/btrfs/extent_io.c

4133

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

4149

if (btrfs_meta_is_subpage(fs_info)) {

fs/btrfs/extent_io.c

4152

if (WARN_ON(!btrfs_subpage_test_uptodate(fs_info, folio,

fs/btrfs/extent_io.c

4154

btrfs_subpage_dump_bitmap(fs_info, folio, eb->start, eb->len);

fs/btrfs/extent_io.c

439

max_bytes = fs_info->sectorsize;

fs/btrfs/extent_io.c

44

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

4526

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

4528

unsigned long start = (folio_pos(folio) >> fs_info->nodesize_bits);

fs/btrfs/extent_io.c

4530

unsigned long end = index + (PAGE_SIZE >> fs_info->nodesize_bits) - 1;

fs/btrfs/extent_io.c

4534

xa_for_each_range(&fs_info->buffer_tree, index, eb, start, end) {

fs/btrfs/extent_io.c

4640

void btrfs_readahead_tree_block(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

4656

eb = btrfs_find_create_tree_block(fs_info, bytenr, owner_root, level);

fs/btrfs/extent_io.c

4686

btrfs_readahead_tree_block(node->fs_info,

fs/btrfs/extent_io.c

47

spin_lock_irqsave(&fs_info->eb_leak_lock, flags);

fs/btrfs/extent_io.c

48

list_add(&eb->leak_list, &fs_info->allocated_ebs);

fs/btrfs/extent_io.c

481

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

483

if (!vi || btrfs_folio_test_uptodate(fs_info, folio, start, len))

fs/btrfs/extent_io.c

49

spin_unlock_irqrestore(&fs_info->eb_leak_lock, flags);

fs/btrfs/extent_io.c

491

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

497

btrfs_folio_set_uptodate(fs_info, folio, start, len);

fs/btrfs/extent_io.c

499

btrfs_folio_clear_uptodate(fs_info, folio, start, len);

fs/btrfs/extent_io.c

501

if (!btrfs_is_subpage(fs_info, folio))

fs/btrfs/extent_io.c

504

btrfs_folio_end_lock(fs_info, folio, start, len);

fs/btrfs/extent_io.c

519

struct btrfs_fs_info *fs_info = bbio->inode->root->fs_info;

fs/btrfs/extent_io.c

532

btrfs_folio_clear_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

54

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

542

static void begin_folio_read(struct btrfs_fs_info *fs_info, struct folio *folio)

fs/btrfs/extent_io.c

545

if (!btrfs_is_subpage(fs_info, folio))

fs/btrfs/extent_io.c

549

btrfs_folio_set_lock(fs_info, folio, folio_pos(folio), folio_size(folio));

fs/btrfs/extent_io.c

566

struct btrfs_fs_info *fs_info = bbio->inode->root->fs_info;

fs/btrfs/extent_io.c

57

spin_lock_irqsave(&fs_info->eb_leak_lock, flags);

fs/btrfs/extent_io.c

582

btrfs_debug(fs_info,

fs/btrfs/extent_io.c

59

spin_unlock_irqrestore(&fs_info->eb_leak_lock, flags);

fs/btrfs/extent_io.c

62

void btrfs_extent_buffer_leak_debug_check(struct btrfs_fs_info *fs_info)

fs/btrfs/extent_io.c

71

if (!fs_info->allocated_ebs.next)

fs/btrfs/extent_io.c

730

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/extent_io.c

74

WARN_ON(!list_empty(&fs_info->allocated_ebs));

fs/btrfs/extent_io.c

75

spin_lock_irqsave(&fs_info->eb_leak_lock, flags);

fs/btrfs/extent_io.c

754

btrfs_err_rl(fs_info,

fs/btrfs/extent_io.c

76

while (!list_empty(&fs_info->allocated_ebs)) {

fs/btrfs/extent_io.c

77

eb = list_first_entry(&fs_info->allocated_ebs,

fs/btrfs/extent_io.c

771

bio_set_dev(&bbio->bio, fs_info->fs_devices->latest_dev->bdev);

fs/btrfs/extent_io.c

79

btrfs_err(fs_info,

fs/btrfs/extent_io.c

87

spin_unlock_irqrestore(&fs_info->eb_leak_lock, flags);

fs/btrfs/extent_io.c

885

inode->root->fs_info->writeback_bio_size)

fs/btrfs/extent_io.c

896

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

908

if (!btrfs_meta_is_subpage(fs_info)) {

fs/btrfs/extent_io.c

927

ret = btrfs_attach_folio_state(fs_info, folio, BTRFS_SUBPAGE_METADATA);

fs/btrfs/extent_io.c

933

struct btrfs_fs_info *fs_info;

fs/btrfs/extent_io.c

940

fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

942

if (btrfs_is_subpage(fs_info, folio))

fs/btrfs/extent_io.c

943

return btrfs_attach_folio_state(fs_info, folio, BTRFS_SUBPAGE_DATA);

fs/btrfs/extent_io.c

951

struct btrfs_fs_info *fs_info;

fs/btrfs/extent_io.c

969

fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

970

if (btrfs_is_subpage(fs_info, folio))

fs/btrfs/extent_io.c

971

return btrfs_detach_folio_state(fs_info, folio, BTRFS_SUBPAGE_DATA);

fs/btrfs/extent_io.h

263

void btrfs_btree_wait_writeback_range(struct btrfs_fs_info *fs_info, u64 start, u64 end);

fs/btrfs/extent_io.h

268

struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.h

270

struct extent_buffer *alloc_dummy_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.h

273

struct extent_buffer *find_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.h

288

void btrfs_readahead_tree_block(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.h

412

struct extent_buffer *alloc_test_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.h

416

void btrfs_extent_buffer_leak_debug_check(struct btrfs_fs_info *fs_info);

fs/btrfs/extent_io.h

418

#define btrfs_extent_buffer_leak_debug_check(fs_info) do {} while (0)

fs/btrfs/extent_io.h

90

struct btrfs_fs_info *fs_info;

fs/btrfs/extent_map.c

1136

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/extent_map.c

1137

const u64 cur_fs_gen = btrfs_get_fs_generation(fs_info);

fs/btrfs/extent_map.c

1197

btrfs_fs_closing(fs_info))

fs/btrfs/extent_map.c

1260

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent_map.c

1263

u64 min_ino = fs_info->em_shrinker_last_ino + 1;

fs/btrfs/extent_map.c

1271

fs_info->em_shrinker_last_ino = btrfs_ino(inode);

fs/btrfs/extent_map.c

1274

if (ctx->scanned >= ctx->nr_to_scan || btrfs_fs_closing(fs_info))

fs/btrfs/extent_map.c

1290

fs_info->em_shrinker_last_root = btrfs_root_id(root);

fs/btrfs/extent_map.c

1296

fs_info->em_shrinker_last_ino = 0;

fs/btrfs/extent_map.c

1297

fs_info->em_shrinker_last_root = btrfs_root_id(root) + 1;

fs/btrfs/extent_map.c

1305

struct btrfs_fs_info *fs_info;

fs/btrfs/extent_map.c

1312

fs_info = container_of(work, struct btrfs_fs_info, em_shrinker_work);

fs/btrfs/extent_map.c

1315

ctx.nr_to_scan = atomic64_read(&fs_info->em_shrinker_nr_to_scan);

fs/btrfs/extent_map.c

1317

start_root_id = fs_info->em_shrinker_last_root;

fs/btrfs/extent_map.c

1318

next_root_id = fs_info->em_shrinker_last_root;

fs/btrfs/extent_map.c

1321

s64 nr = percpu_counter_sum_positive(&fs_info->evictable_extent_maps);

fs/btrfs/extent_map.c

1323

trace_call__btrfs_extent_map_shrinker_scan_enter(fs_info, nr);

fs/btrfs/extent_map.c

1326

while (ctx.scanned < ctx.nr_to_scan && !btrfs_fs_closing(fs_info)) {

fs/btrfs/extent_map.c

1332

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/extent_map.c

1333

count = radix_tree_gang_lookup(&fs_info->fs_roots_radix,

fs/btrfs/extent_map.c

1337

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/extent_map.c

1340

fs_info->em_shrinker_last_root = 0;

fs/btrfs/extent_map.c

1341

fs_info->em_shrinker_last_ino = 0;

fs/btrfs/extent_map.c

1349

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/extent_map.c

1361

s64 nr = percpu_counter_sum_positive(&fs_info->evictable_extent_maps);

fs/btrfs/extent_map.c

1363

trace_call__btrfs_extent_map_shrinker_scan_exit(fs_info, nr_dropped, nr);

fs/btrfs/extent_map.c

1366

atomic64_set(&fs_info->em_shrinker_nr_to_scan, 0);

fs/btrfs/extent_map.c

1369

void btrfs_free_extent_maps(struct btrfs_fs_info *fs_info, long nr_to_scan)

fs/btrfs/extent_map.c

1386

if (atomic64_cmpxchg(&fs_info->em_shrinker_nr_to_scan, 0, nr_to_scan) != 0)

fs/btrfs/extent_map.c

1389

queue_work(system_dfl_wq, &fs_info->em_shrinker_work);

fs/btrfs/extent_map.c

1392

void btrfs_init_extent_map_shrinker_work(struct btrfs_fs_info *fs_info)

fs/btrfs/extent_map.c

1394

atomic64_set(&fs_info->em_shrinker_nr_to_scan, 0);

fs/btrfs/extent_map.c

1395

INIT_WORK(&fs_info->em_shrinker_work, btrfs_extent_map_shrinker_worker);

fs/btrfs/extent_map.c

307

static void dump_extent_map(struct btrfs_fs_info *fs_info, const char *prefix,

fs/btrfs/extent_map.c

312

btrfs_crit(fs_info,

fs/btrfs/extent_map.c

320

static void validate_extent_map(struct btrfs_fs_info *fs_info, struct extent_map *em)

fs/btrfs/extent_map.c

322

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/extent_map.c

329

dump_extent_map(fs_info, "unaligned start offset or length members", em);

fs/btrfs/extent_map.c

333

dump_extent_map(fs_info, "zero disk_num_bytes", em);

fs/btrfs/extent_map.c

335

dump_extent_map(fs_info, "ram_bytes too small", em);

fs/btrfs/extent_map.c

338

dump_extent_map(fs_info, "disk_num_bytes too small", em);

fs/btrfs/extent_map.c

341

dump_extent_map(fs_info,

fs/btrfs/extent_map.c

348

dump_extent_map(fs_info, "unaligned members", em);

fs/btrfs/extent_map.c

350

dump_extent_map(fs_info, "non-zero offset for hole/inline", em);

fs/btrfs/extent_map.c

356

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/extent_map.c

387

validate_extent_map(fs_info, em);

fs/btrfs/extent_map.c

400

validate_extent_map(fs_info, em);

fs/btrfs/extent_map.c

426

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/extent_map.c

435

btrfs_warn(fs_info,

fs/btrfs/extent_map.c

444

btrfs_warn(fs_info,

fs/btrfs/extent_map.c

505

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent_map.c

510

validate_extent_map(fs_info, em);

fs/btrfs/extent_map.c

517

if (!btrfs_is_testing(fs_info) && btrfs_is_fstree(btrfs_root_id(root)))

fs/btrfs/extent_map.c

518

percpu_counter_inc(&fs_info->evictable_extent_maps);

fs/btrfs/extent_map.c

611

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/extent_map.c

616

validate_extent_map(fs_info, new);

fs/btrfs/extent_map.c

713

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/extent_map.c

732

trace_btrfs_handle_em_exist(fs_info, existing, em, start, len);

fs/btrfs/extent_map.c

755

btrfs_warn(fs_info,

fs/btrfs/extent_map.c

82

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/extent_map.c

87

if (!btrfs_is_testing(fs_info) && btrfs_is_fstree(btrfs_root_id(inode->root)))

fs/btrfs/extent_map.c

88

percpu_counter_dec(&fs_info->evictable_extent_maps);

fs/btrfs/extent_map.h

192

void btrfs_free_extent_maps(struct btrfs_fs_info *fs_info, long nr_to_scan);

fs/btrfs/extent_map.h

193

void btrfs_init_extent_map_shrinker_work(struct btrfs_fs_info *fs_info);

fs/btrfs/fiemap.c

644

const u64 sectorsize = inode->root->fs_info->sectorsize;

fs/btrfs/file-item.c

1130

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file-item.c

1145

const u32 csum_size = fs_info->csum_size;

fs/btrfs/file-item.c

1178

MAX_CSUM_ITEMS(fs_info, csum_size)) {

fs/btrfs/file-item.c

1204

fs_info->sectorsize_bits;

fs/btrfs/file-item.c

121

ASSERT(IS_ALIGNED(start + len, inode->root->fs_info->sectorsize) ||

fs/btrfs/file-item.c

1224

csum_offset = (bytenr - found_key.offset) >> fs_info->sectorsize_bits;

fs/btrfs/file-item.c

1228

csum_offset >= MAX_CSUM_ITEMS(fs_info, csum_size)) {

fs/btrfs/file-item.c

1240

tmp >>= fs_info->sectorsize_bits;

fs/btrfs/file-item.c

1279

tmp = (next_offset - bytenr) >> fs_info->sectorsize_bits;

fs/btrfs/file-item.c

128

static size_t bytes_to_csum_size(const struct btrfs_fs_info *fs_info, u32 bytes)

fs/btrfs/file-item.c

1286

MAX_CSUM_ITEMS(fs_info, csum_size) * csum_size);

fs/btrfs/file-item.c

130

ASSERT(IS_ALIGNED(bytes, fs_info->sectorsize));

fs/btrfs/file-item.c

1305

tmp >>= fs_info->sectorsize_bits;

fs/btrfs/file-item.c

1307

fs_info->sectorsize_bits);

fs/btrfs/file-item.c

1310

tmp = min_t(u64, tmp, MAX_CSUM_ITEMS(fs_info, csum_size));

fs/btrfs/file-item.c

132

return (bytes >> fs_info->sectorsize_bits) * fs_info->csum_size;

fs/btrfs/file-item.c

1327

ins_size = (u32)(sums->len - total_bytes) >> fs_info->sectorsize_bits;

fs/btrfs/file-item.c

1336

total_bytes += (ins_size << fs_info->sectorsize_bits);

fs/btrfs/file-item.c

135

static size_t csum_size_to_bytes(const struct btrfs_fs_info *fs_info, u32 csum_size)

fs/btrfs/file-item.c

1352

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file-item.c

137

ASSERT(IS_ALIGNED(csum_size, fs_info->csum_size));

fs/btrfs/file-item.c

139

return (csum_size / fs_info->csum_size) << fs_info->sectorsize_bits;

fs/btrfs/file-item.c

1399

em->len = fs_info->sectorsize;

fs/btrfs/file-item.c

1403

btrfs_err(fs_info,

fs/btrfs/file-item.c

142

static inline u32 max_ordered_sum_bytes(const struct btrfs_fs_info *fs_info)

fs/btrfs/file-item.c

1428

end = leaf->fs_info->sectorsize;

fs/btrfs/file-item.c

145

fs_info->csum_size);

fs/btrfs/file-item.c

147

return csum_size_to_bytes(fs_info, max_csum_size);

fs/btrfs/file-item.c

154

static int btrfs_ordered_sum_size(const struct btrfs_fs_info *fs_info, unsigned long bytes)

fs/btrfs/file-item.c

156

return sizeof(struct btrfs_ordered_sum) + bytes_to_csum_size(fs_info, bytes);

fs/btrfs/file-item.c

204

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file-item.c

211

const u32 csum_size = fs_info->csum_size;

fs/btrfs/file-item.c

231

fs_info->sectorsize_bits;

fs/btrfs/file-item.c

277

static int search_csum_tree(struct btrfs_fs_info *fs_info,

fs/btrfs/file-item.c

284

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/file-item.c

285

const u32 csum_size = fs_info->csum_size;

fs/btrfs/file-item.c

310

csum_root = btrfs_csum_root(fs_info, disk_bytenr);

fs/btrfs/file-item.c

312

btrfs_err(fs_info,

fs/btrfs/file-item.c

334

disk_bytenr) >> fs_info->sectorsize_bits;

fs/btrfs/file-item.c

351

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file-item.c

354

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/file-item.c

355

const u32 csum_size = fs_info->csum_size;

fs/btrfs/file-item.c

358

const unsigned int nblocks = orig_len >> fs_info->sectorsize_bits;

fs/btrfs/file-item.c

364

test_bit(BTRFS_FS_STATE_NO_DATA_CSUMS, &fs_info->fs_state))

fs/btrfs/file-item.c

396

if (nblocks > fs_info->csums_per_leaf)

fs/btrfs/file-item.c

438

down_read(&fs_info->commit_root_sem);

fs/btrfs/file-item.c

445

(bio_offset >> fs_info->sectorsize_bits) * csum_size;

fs/btrfs/file-item.c

447

count = search_csum_tree(fs_info, path, cur_disk_bytenr,

fs/btrfs/file-item.c

482

up_read(&fs_info->commit_root_sem);

fs/btrfs/file-item.c

500

btrfs_warn_rl(fs_info,

fs/btrfs/file-item.c

509

up_read(&fs_info->commit_root_sem);

fs/btrfs/file-item.c

530

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file-item.c

539

ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&

fs/btrfs/file-item.c

540

IS_ALIGNED(end + 1, fs_info->sectorsize));

fs/btrfs/file-item.c

576

if (bytes_to_csum_size(fs_info, start - key.offset) <

fs/btrfs/file-item.c

604

csum_end = key.offset + csum_size_to_bytes(fs_info,

fs/btrfs/file-item.c

623

max_ordered_sum_bytes(fs_info));

fs/btrfs/file-item.c

624

sums = kzalloc(btrfs_ordered_sum_size(fs_info, size),

fs/btrfs/file-item.c

634

offset = bytes_to_csum_size(fs_info, start - key.offset);

fs/btrfs/file-item.c

639

bytes_to_csum_size(fs_info, size));

fs/btrfs/file-item.c

675

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file-item.c

683

ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&

fs/btrfs/file-item.c

684

IS_ALIGNED(end + 1, fs_info->sectorsize));

fs/btrfs/file-item.c

732

if (bytes_to_csum_size(fs_info, start - key.offset) <

fs/btrfs/file-item.c

761

csum_end = key.offset + csum_size_to_bytes(fs_info,

fs/btrfs/file-item.c

774

u8 *csum_dest = csum_buf + bytes_to_csum_size(fs_info,

fs/btrfs/file-item.c

779

offset = bytes_to_csum_size(fs_info, start - key.offset);

fs/btrfs/file-item.c

783

bytes_to_csum_size(fs_info, size));

fs/btrfs/file-item.c

786

(start - orig_start) >> fs_info->sectorsize_bits,

fs/btrfs/file-item.c

787

size >> fs_info->sectorsize_bits);

fs/btrfs/file-item.c

803

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file-item.c

808

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/file-item.c

820

btrfs_calculate_block_csum_pages(fs_info, paddrs, sums->sums + index);

fs/btrfs/file-item.c

821

index += fs_info->csum_size;

fs/btrfs/file-item.c

843

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file-item.c

849

sums = kvzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size),

fs/btrfs/file-item.c

907

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/file-item.c

909

const u32 csum_size = fs_info->csum_size;

fs/btrfs/file-item.c

912

u32 blocksize_bits = fs_info->sectorsize_bits;

fs/btrfs/file-item.c

92

ASSERT(IS_ALIGNED(start + len, inode->root->fs_info->sectorsize));

fs/btrfs/file-item.c

955

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/file-item.c

962

const u32 csum_size = fs_info->csum_size;

fs/btrfs/file-item.c

963

u32 blocksize_bits = fs_info->sectorsize_bits;

fs/btrfs/file.c

1037

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/file.c

1070

loff_t end_pos = round_up(pos + count, fs_info->sectorsize);

fs/btrfs/file.c

1090

const struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file.c

1093

round_down(start, fs_info->sectorsize),

fs/btrfs/file.c

1109

const struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file.c

1110

const unsigned int block_offset = (start & (fs_info->sectorsize - 1));

fs/btrfs/file.c

1135

reserve_bytes = round_up(*len + block_offset, fs_info->sectorsize);

fs/btrfs/file.c

1191

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file.c

1195

const u64 reserved_start = round_down(start, fs_info->sectorsize);

fs/btrfs/file.c

125

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file.c

1299

btrfs_drop_folio(fs_info, folio, start, copied);

fs/btrfs/file.c

1304

last_block = round_up(start + copied, fs_info->sectorsize);

fs/btrfs/file.c

1328

btrfs_drop_folio(fs_info, folio, start, copied);

fs/btrfs/file.c

1336

btrfs_drop_folio(fs_info, folio, start, copied);

fs/btrfs/file.c

1432

if (btrfs_is_shutdown(inode->root->fs_info))

fs/btrfs/file.c

1439

if (unlikely(BTRFS_FS_ERROR(inode->root->fs_info)))

fs/btrfs/file.c

1516

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file.c

1518

if (btrfs_inode_in_log(inode, btrfs_get_fs_generation(fs_info)) &&

fs/btrfs/file.c

1529

if (inode->last_trans <= btrfs_get_last_trans_committed(fs_info) &&

fs/btrfs/file.c

1553

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file.c

1652

if (full_sync || btrfs_is_zoned(fs_info)) {

fs/btrfs/file.c

1846

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file.c

1941

reserved_space = round_up(size - page_start, fs_info->sectorsize);

fs/btrfs/file.c

1969

btrfs_folio_set_dirty(fs_info, folio, page_start, end + 1 - page_start);

fs/btrfs/file.c

1970

btrfs_folio_set_uptodate(fs_info, folio, page_start, end + 1 - page_start);

fs/btrfs/file.c

2068

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/file.c

2080

if (btrfs_fs_incompat(fs_info, NO_HOLES))

fs/btrfs/file.c

2180

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file.c

2185

round_down(*start, fs_info->sectorsize),

fs/btrfs/file.c

2186

round_up(*len, fs_info->sectorsize));

fs/btrfs/file.c

2301

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/file.c

2313

btrfs_fs_incompat(fs_info, NO_HOLES)) {

fs/btrfs/file.c

2397

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file.c

2398

const u64 min_size = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/file.c

2399

u64 ino_size = round_up(inode->vfs_inode.i_size, fs_info->sectorsize);

fs/btrfs/file.c

2410

btrfs_init_metadata_block_rsv(fs_info, &rsv, BTRFS_BLOCK_RSV_TEMP);

fs/btrfs/file.c

2420

if (!btrfs_fs_incompat(fs_info, NO_HOLES) || extent_info)

fs/btrfs/file.c

2432

ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, &rsv,

fs/btrfs/file.c

2465

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/file.c

2542

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/file.c

2551

ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv,

fs/btrfs/file.c

2582

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/file.c

2634

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/file.c

2640

btrfs_block_rsv_release(fs_info, &rsv, (u64)-1, NULL);

fs/btrfs/file.c

2647

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/file.c

2670

ino_size = round_up(inode->i_size, fs_info->sectorsize);

fs/btrfs/file.c

2684

lockstart = round_up(offset, fs_info->sectorsize);

fs/btrfs/file.c

2685

lockend = round_down(offset + len, fs_info->sectorsize) - 1;

fs/btrfs/file.c

2686

same_block = (BTRFS_BYTES_TO_BLKS(fs_info, offset))

fs/btrfs/file.c

2687

== (BTRFS_BYTES_TO_BLKS(fs_info, offset + len - 1));

fs/btrfs/file.c

2692

if (same_block && len < fs_info->sectorsize) {

fs/btrfs/file.c

2776

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/file.c

2861

range_start = round_down(i_size_read(inode), root->fs_info->sectorsize);

fs/btrfs/file.c

2862

range_end = round_up(end, root->fs_info->sectorsize);

fs/btrfs/file.c

2891

const u64 sectorsize = inode->root->fs_info->sectorsize;

fs/btrfs/file.c

2916

struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;

fs/btrfs/file.c

2921

const u64 sectorsize = fs_info->sectorsize;

fs/btrfs/file.c

2970

if (BTRFS_BYTES_TO_BLKS(fs_info, offset) ==

fs/btrfs/file.c

2971

BTRFS_BYTES_TO_BLKS(fs_info, offset + len - 1)) {

fs/btrfs/file.c

3068

fs_info->sectorsize,

fs/btrfs/file.c

3108

int blocksize = BTRFS_I(inode)->root->fs_info->sectorsize;

fs/btrfs/file.c

3417

u64 cur_offset = round_down(start, inode->root->fs_info->sectorsize);

fs/btrfs/file.c

3528

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file.c

3605

lockstart = round_down(start, fs_info->sectorsize);

fs/btrfs/file.c

3606

lockend = round_up(i_size, fs_info->sectorsize);

fs/btrfs/file.c

3608

lockend = lockstart + fs_info->sectorsize;

fs/btrfs/file.c

398

fs_info->sectorsize);

fs/btrfs/file.c

45

static void btrfs_drop_folio(struct btrfs_fs_info *fs_info, struct folio *folio,

fs/btrfs/file.c

48

u64 block_start = round_down(pos, fs_info->sectorsize);

fs/btrfs/file.c

49

u64 block_len = round_up(pos + copied, fs_info->sectorsize) - block_start;

fs/btrfs/file.c

66

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file.c

81

start_pos = round_down(pos, fs_info->sectorsize);

fs/btrfs/file.c

82

num_bytes = round_up(end_pos - start_pos, fs_info->sectorsize);

fs/btrfs/file.c

891

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file.c

896

start_pos = round_down(pos, fs_info->sectorsize);

fs/btrfs/file.c

897

last_pos = round_up(pos + write_bytes, fs_info->sectorsize) - 1;

fs/btrfs/file.c

93

btrfs_folio_clamp_set_uptodate(fs_info, folio, start_pos, num_bytes);

fs/btrfs/file.c

94

btrfs_folio_clamp_set_dirty(fs_info, folio, start_pos, num_bytes);

fs/btrfs/file.c

968

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/file.c

981

lockstart = round_down(pos, fs_info->sectorsize);

fs/btrfs/file.c

983

fs_info->sectorsize) - 1;

fs/btrfs/free-space-cache.c

1016

ret = __load_free_space_cache(fs_info->tree_root, inode, &tmp_ctl,

fs/btrfs/free-space-cache.c

1043

btrfs_warn(fs_info,

fs/btrfs/free-space-cache.c

1056

btrfs_warn(fs_info,

fs/btrfs/free-space-cache.c

1313

btrfs_debug(root->fs_info,

fs/btrfs/free-space-cache.c

1350

return __btrfs_wait_cache_io(block_group->fs_info->tree_root, trans,

fs/btrfs/free-space-cache.c

136

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.c

147

inode = __lookup_free_space_inode(fs_info->tree_root, path,

fs/btrfs/free-space-cache.c

1516

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/free-space-cache.c

1533

btrfs_debug(fs_info,

fs/btrfs/free-space-cache.c

154

btrfs_info(fs_info, "Old style space inode found, converting.");

fs/btrfs/free-space-cache.c

1571

bytes_per_bitmap = BITS_PER_BITMAP * ctl->block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

1702

const int unit = ctl->block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

1875

const int unit = ctl->block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

1912

const int unit = ctl->block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

1954

const int unit = ctl->block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

2151

const int unit = ctl->block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

2229

const int unit = ctl->block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

2261

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.c

2285

if (info->bytes <= fs_info->sectorsize * 8) {

fs/btrfs/free-space-cache.c

2301

if (((BITS_PER_BITMAP * fs_info->sectorsize) >> 1) > block_group->length)

fs/btrfs/free-space-cache.c

231

ret = btrfs_get_free_objectid(trans->fs_info->tree_root, &ino);

fs/btrfs/free-space-cache.c

2321

if (btrfs_is_testing(block_group->fs_info)) {

fs/btrfs/free-space-cache.c

2322

if (!block_group->fs_info->use_bitmap(ctl, info))

fs/btrfs/free-space-cache.c

235

return __create_free_space_inode(trans->fs_info->tree_root, trans, path,

fs/btrfs/free-space-cache.c

2498

const int unit = ctl->block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

2533

const int unit = ctl->block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

2624

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.c

2630

ASSERT(!btrfs_is_zoned(fs_info));

fs/btrfs/free-space-cache.c

2678

btrfs_crit(fs_info, "unable to add free space :%d", ret);

fs/btrfs/free-space-cache.c

2684

btrfs_discard_queue_work(&fs_info->discard_ctl, block_group);

fs/btrfs/free-space-cache.c

2759

if (btrfs_is_zoned(block_group->fs_info))

fs/btrfs/free-space-cache.c

2763

if (btrfs_test_opt(block_group->fs_info, DISCARD_SYNC))

fs/btrfs/free-space-cache.c

2772

if (btrfs_is_zoned(block_group->fs_info))

fs/btrfs/free-space-cache.c

2789

if (btrfs_is_zoned(block_group->fs_info))

fs/btrfs/free-space-cache.c

2793

if (btrfs_test_opt(block_group->fs_info, DISCARD_SYNC) ||

fs/btrfs/free-space-cache.c

2794

btrfs_test_opt(block_group->fs_info, DISCARD_ASYNC))

fs/btrfs/free-space-cache.c

2808

if (btrfs_is_zoned(block_group->fs_info)) {

fs/btrfs/free-space-cache.c

284

ret = btrfs_search_slot(trans, trans->fs_info->tree_root, &key, path,

fs/btrfs/free-space-cache.c

291

return btrfs_del_item(trans, trans->fs_info->tree_root, path);

fs/btrfs/free-space-cache.c

2916

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.c

2926

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/free-space-cache.c

2927

btrfs_info(fs_info, "free space %llu active %d",

fs/btrfs/free-space-cache.c

2939

btrfs_crit(fs_info, "entry offset %llu, bytes %llu, bitmap %s",

fs/btrfs/free-space-cache.c

2943

btrfs_info(fs_info, "block group has cluster?: %s",

fs/btrfs/free-space-cache.c

2945

btrfs_info(fs_info,

fs/btrfs/free-space-cache.c

3091

&block_group->fs_info->discard_ctl;

fs/btrfs/free-space-cache.c

3100

ASSERT(!btrfs_is_zoned(block_group->fs_info));

fs/btrfs/free-space-cache.c

3183

btrfs_discard_queue_work(&block_group->fs_info->discard_ctl, block_group);

fs/btrfs/free-space-cache.c

3228

&block_group->fs_info->discard_ctl;

fs/btrfs/free-space-cache.c

3233

ASSERT(!btrfs_is_zoned(block_group->fs_info));

fs/btrfs/free-space-cache.c

3328

const int unit = block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

3562

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.c

3576

if (btrfs_test_opt(fs_info, SSD_SPREAD)) {

fs/btrfs/free-space-cache.c

3581

min_bytes = fs_info->sectorsize;

fs/btrfs/free-space-cache.c

3584

min_bytes = fs_info->sectorsize;

fs/btrfs/free-space-cache.c

3657

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.c

3678

ret = btrfs_discard_extent(fs_info, start, bytes, &trimmed, false);

fs/btrfs/free-space-cache.c

3720

&block_group->fs_info->discard_ctl;

fs/btrfs/free-space-cache.c

3837

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/free-space-cache.c

3838

struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl;

fs/btrfs/free-space-cache.c

3848

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/free-space-cache.c

3853

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/free-space-cache.c

3867

ret = btrfs_discard_extent(fs_info, bg->discard_cursor, bytes, &trimmed, false);

fs/btrfs/free-space-cache.c

3930

&block_group->fs_info->discard_ctl;

fs/btrfs/free-space-cache.c

396

io_ctl->fs_info = inode_to_fs_info(inode);

fs/btrfs/free-space-cache.c

4045

const int unit = block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

4074

const int unit = block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

4078

ASSERT(!btrfs_is_zoned(block_group->fs_info));

fs/btrfs/free-space-cache.c

4150

bool btrfs_free_space_cache_v1_active(struct btrfs_fs_info *fs_info)

fs/btrfs/free-space-cache.c

4152

return btrfs_super_cache_generation(fs_info->super_copy);

fs/btrfs/free-space-cache.c

4155

static int cleanup_free_space_cache_v1(struct btrfs_fs_info *fs_info,

fs/btrfs/free-space-cache.c

4161

btrfs_info(fs_info, "cleaning free space cache v1");

fs/btrfs/free-space-cache.c

4163

node = rb_first_cached(&fs_info->block_group_cache_tree);

fs/btrfs/free-space-cache.c

4176

int btrfs_set_free_space_cache_v1_active(struct btrfs_fs_info *fs_info, bool active)

fs/btrfs/free-space-cache.c

4189

trans = btrfs_start_transaction(fs_info->tree_root, 0);

fs/btrfs/free-space-cache.c

4194

set_bit(BTRFS_FS_CLEANUP_SPACE_CACHE_V1, &fs_info->flags);

fs/btrfs/free-space-cache.c

4195

ret = cleanup_free_space_cache_v1(fs_info, trans);

fs/btrfs/free-space-cache.c

4205

clear_bit(BTRFS_FS_CLEANUP_SPACE_CACHE_V1, &fs_info->flags);

fs/btrfs/free-space-cache.c

4314

const int unit = cache->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

473

btrfs_err(BTRFS_I(inode)->root->fs_info,

fs/btrfs/free-space-cache.c

479

btrfs_err(BTRFS_I(inode)->root->fs_info,

fs/btrfs/free-space-cache.c

521

btrfs_err_rl(io_ctl->fs_info,

fs/btrfs/free-space-cache.c

568

btrfs_err_rl(io_ctl->fs_info,

fs/btrfs/free-space-cache.c

692

const int unit = block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

703

btrfs_err(block_group->fs_info,

fs/btrfs/free-space-cache.c

738

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/free-space-cache.c

778

btrfs_info(fs_info,

fs/btrfs/free-space-cache.c

785

btrfs_err(fs_info,

fs/btrfs/free-space-cache.c

837

btrfs_err(fs_info,

fs/btrfs/free-space-cache.c

857

btrfs_err(fs_info,

fs/btrfs/free-space-cache.c

918

u64 bytes = ctl->block_group->fs_info->sectorsize;

fs/btrfs/free-space-cache.c

941

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.h

163

bool btrfs_free_space_cache_v1_active(struct btrfs_fs_info *fs_info);

fs/btrfs/free-space-cache.h

164

int btrfs_set_free_space_cache_v1_active(struct btrfs_fs_info *fs_info, bool active);

fs/btrfs/free-space-cache.h

95

struct btrfs_fs_info *fs_info;

fs/btrfs/free-space-tree.c

100

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-tree.c

1028

if (!btrfs_fs_compat_ro(trans->fs_info, FREE_SPACE_TREE))

fs/btrfs/free-space-tree.c

1038

block_group = btrfs_lookup_block_group(trans->fs_info, start);

fs/btrfs/free-space-tree.c

1086

extent_root = btrfs_extent_root(trans->fs_info, block_group->start);

fs/btrfs/free-space-tree.c

1088

btrfs_err(trans->fs_info,

fs/btrfs/free-space-tree.c

113

btrfs_warn(fs_info, "missing free space info for %llu",

fs/btrfs/free-space-tree.c

1144

start += trans->fs_info->nodesize;

fs/btrfs/free-space-tree.c

1170

int btrfs_create_free_space_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/free-space-tree.c

1173

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/free-space-tree.c

1183

set_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);

fs/btrfs/free-space-tree.c

1184

set_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags);

fs/btrfs/free-space-tree.c

1201

node = rb_first_cached(&fs_info->block_group_cache_tree);

fs/btrfs/free-space-tree.c

1214

btrfs_set_fs_compat_ro(fs_info, FREE_SPACE_TREE);

fs/btrfs/free-space-tree.c

1215

btrfs_set_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID);

fs/btrfs/free-space-tree.c

1216

clear_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);

fs/btrfs/free-space-tree.c

1223

clear_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags);

fs/btrfs/free-space-tree.c

1227

clear_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);

fs/btrfs/free-space-tree.c

1228

clear_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags);

fs/btrfs/free-space-tree.c

1266

node = rb_first_cached(&trans->fs_info->block_group_cache_tree);

fs/btrfs/free-space-tree.c

1279

int btrfs_delete_free_space_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/free-space-tree.c

1282

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/free-space-tree.c

1288

struct btrfs_root *free_space_root = btrfs_global_root(fs_info, &key);

fs/btrfs/free-space-tree.c

1295

btrfs_clear_fs_compat_ro(fs_info, FREE_SPACE_TREE);

fs/btrfs/free-space-tree.c

1296

btrfs_clear_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID);

fs/btrfs/free-space-tree.c

1314

spin_lock(&fs_info->trans_lock);

fs/btrfs/free-space-tree.c

1316

spin_unlock(&fs_info->trans_lock);

fs/btrfs/free-space-tree.c

1333

int btrfs_rebuild_free_space_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/free-space-tree.c

1341

struct btrfs_root *free_space_root = btrfs_global_root(fs_info, &key);

fs/btrfs/free-space-tree.c

1349

set_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);

fs/btrfs/free-space-tree.c

1350

set_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags);

fs/btrfs/free-space-tree.c

1359

node = rb_first_cached(&fs_info->block_group_cache_tree);

fs/btrfs/free-space-tree.c

1386

btrfs_set_fs_compat_ro(fs_info, FREE_SPACE_TREE);

fs/btrfs/free-space-tree.c

1387

btrfs_set_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID);

fs/btrfs/free-space-tree.c

1388

clear_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);

fs/btrfs/free-space-tree.c

1391

clear_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags);

fs/btrfs/free-space-tree.c

1461

if (!btrfs_fs_compat_ro(trans->fs_info, FREE_SPACE_TREE))

fs/btrfs/free-space-tree.c

1482

if (!btrfs_fs_compat_ro(trans->fs_info, FREE_SPACE_TREE))

fs/btrfs/free-space-tree.c

152

static inline u32 free_space_bitmap_size(const struct btrfs_fs_info *fs_info,

fs/btrfs/free-space-tree.c

1532

btrfs_err(trans->fs_info, "unexpected free space tree key type %u",

fs/btrfs/free-space-tree.c

155

return DIV_ROUND_UP(size >> fs_info->sectorsize_bits, BITS_PER_BYTE);

fs/btrfs/free-space-tree.c

1557

btrfs_err(block_group->fs_info,

fs/btrfs/free-space-tree.c

1564

btrfs_err(block_group->fs_info,

fs/btrfs/free-space-tree.c

1579

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-tree.c

1633

offset += fs_info->sectorsize;

fs/btrfs/free-space-tree.c

1644

btrfs_err(fs_info,

fs/btrfs/free-space-tree.c

1660

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-tree.c

1701

btrfs_err(fs_info,

fs/btrfs/free-space-tree.c

1793

btrfs_info(fst_root->fs_info, "deleted orphan free space tree entries");

fs/btrfs/free-space-tree.c

1798

int btrfs_delete_orphan_free_space_entries(struct btrfs_fs_info *fs_info)

fs/btrfs/free-space-tree.c

1817

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))

fs/btrfs/free-space-tree.c

1819

if (!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE))

fs/btrfs/free-space-tree.c

1821

root = btrfs_global_root(fs_info, &key);

fs/btrfs/free-space-tree.c

1829

bg = btrfs_lookup_first_block_group(fs_info, 0);

fs/btrfs/free-space-tree.c

1831

btrfs_err(fs_info, "no block group found");

fs/btrfs/free-space-tree.c

201

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/free-space-tree.c

216

bitmap_size = free_space_bitmap_size(fs_info, block_group->length);

fs/btrfs/free-space-tree.c

254

fs_info->sectorsize);

fs/btrfs/free-space-tree.c

256

fs_info->sectorsize);

fs/btrfs/free-space-tree.c

263

btrfs_err(fs_info, "unexpected free space tree key type %u",

fs/btrfs/free-space-tree.c

295

btrfs_err(fs_info,

fs/btrfs/free-space-tree.c

305

bitmap_range = fs_info->sectorsize * BTRFS_FREE_SPACE_BITMAP_BITS;

fs/btrfs/free-space-tree.c

313

data_size = free_space_bitmap_size(fs_info, extent_size);

fs/btrfs/free-space-tree.c

32

if (btrfs_fs_incompat(block_group->fs_info, EXTENT_TREE_V2))

fs/btrfs/free-space-tree.c

34

return btrfs_global_root(block_group->fs_info, &key);

fs/btrfs/free-space-tree.c

347

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/free-space-tree.c

361

bitmap_size = free_space_bitmap_size(fs_info, block_group->length);

fs/btrfs/free-space-tree.c

401

fs_info->sectorsize *

fs/btrfs/free-space-tree.c

404

data_size = free_space_bitmap_size(fs_info,

fs/btrfs/free-space-tree.c

414

btrfs_err(fs_info, "unexpected free space tree key type %u",

fs/btrfs/free-space-tree.c

44

btrfs_warn(cache->fs_info, "block group %llu length is zero",

fs/btrfs/free-space-tree.c

445

nrbits = block_group->length >> fs_info->sectorsize_bits;

fs/btrfs/free-space-tree.c

452

key.objectid = start + start_bit * fs_info->sectorsize;

fs/btrfs/free-space-tree.c

454

key.offset = (end_bit - start_bit) * fs_info->sectorsize;

fs/btrfs/free-space-tree.c

469

btrfs_err(fs_info,

fs/btrfs/free-space-tree.c

51

bitmap_range = cache->fs_info->sectorsize * BTRFS_FREE_SPACE_BITMAP_BITS;

fs/btrfs/free-space-tree.c

538

block_group->fs_info->sectorsize);

fs/btrfs/free-space-tree.c

547

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-tree.c

567

first = (*start - found_start) >> fs_info->sectorsize_bits;

fs/btrfs/free-space-tree.c

568

last = (end - found_start) >> fs_info->sectorsize_bits;

fs/btrfs/free-space-tree.c

629

u64 prev_block = start - block_group->fs_info->sectorsize;

fs/btrfs/free-space-tree.c

847

if (!btrfs_fs_compat_ro(trans->fs_info, FREE_SPACE_TREE))

fs/btrfs/free-space-tree.c

857

block_group = btrfs_lookup_block_group(trans->fs_info, start);

fs/btrfs/free-space-tree.h

26

int btrfs_create_free_space_tree(struct btrfs_fs_info *fs_info);

fs/btrfs/free-space-tree.h

27

int btrfs_delete_free_space_tree(struct btrfs_fs_info *fs_info);

fs/btrfs/free-space-tree.h

28

int btrfs_rebuild_free_space_tree(struct btrfs_fs_info *fs_info);

fs/btrfs/free-space-tree.h

38

int btrfs_delete_orphan_free_space_entries(struct btrfs_fs_info *fs_info);

fs/btrfs/fs.c

180

bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,

fs/btrfs/fs.c

185

spin_lock(&fs_info->super_lock);

fs/btrfs/fs.c

186

if (fs_info->exclusive_operation == BTRFS_EXCLOP_NONE) {

fs/btrfs/fs.c

187

fs_info->exclusive_operation = type;

fs/btrfs/fs.c

190

spin_unlock(&fs_info->super_lock);

fs/btrfs/fs.c

206

bool btrfs_exclop_start_try_lock(struct btrfs_fs_info *fs_info,

fs/btrfs/fs.c

209

spin_lock(&fs_info->super_lock);

fs/btrfs/fs.c

210

if (fs_info->exclusive_operation == type ||

fs/btrfs/fs.c

211

(fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED &&

fs/btrfs/fs.c

215

spin_unlock(&fs_info->super_lock);

fs/btrfs/fs.c

219

void btrfs_exclop_start_unlock(struct btrfs_fs_info *fs_info)

fs/btrfs/fs.c

221

spin_unlock(&fs_info->super_lock);

fs/btrfs/fs.c

224

void btrfs_exclop_finish(struct btrfs_fs_info *fs_info)

fs/btrfs/fs.c

226

spin_lock(&fs_info->super_lock);

fs/btrfs/fs.c

227

WRITE_ONCE(fs_info->exclusive_operation, BTRFS_EXCLOP_NONE);

fs/btrfs/fs.c

228

spin_unlock(&fs_info->super_lock);

fs/btrfs/fs.c

229

sysfs_notify(&fs_info->fs_devices->fsid_kobj, NULL, "exclusive_operation");

fs/btrfs/fs.c

232

void btrfs_exclop_balance(struct btrfs_fs_info *fs_info,

fs/btrfs/fs.c

237

spin_lock(&fs_info->super_lock);

fs/btrfs/fs.c

238

ASSERT(fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE ||

fs/btrfs/fs.c

239

fs_info->exclusive_operation == BTRFS_EXCLOP_DEV_ADD ||

fs/btrfs/fs.c

240

fs_info->exclusive_operation == BTRFS_EXCLOP_NONE ||

fs/btrfs/fs.c

241

fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED);

fs/btrfs/fs.c

242

fs_info->exclusive_operation = BTRFS_EXCLOP_BALANCE_PAUSED;

fs/btrfs/fs.c

243

spin_unlock(&fs_info->super_lock);

fs/btrfs/fs.c

246

spin_lock(&fs_info->super_lock);

fs/btrfs/fs.c

247

ASSERT(fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED);

fs/btrfs/fs.c

248

fs_info->exclusive_operation = BTRFS_EXCLOP_BALANCE;

fs/btrfs/fs.c

249

spin_unlock(&fs_info->super_lock);

fs/btrfs/fs.c

252

btrfs_warn(fs_info,

fs/btrfs/fs.c

257

void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,

fs/btrfs/fs.c

263

disk_super = fs_info->super_copy;

fs/btrfs/fs.c

266

spin_lock(&fs_info->super_lock);

fs/btrfs/fs.c

271

btrfs_info(fs_info,

fs/btrfs/fs.c

275

spin_unlock(&fs_info->super_lock);

fs/btrfs/fs.c

276

set_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags);

fs/btrfs/fs.c

280

void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,

fs/btrfs/fs.c

286

disk_super = fs_info->super_copy;

fs/btrfs/fs.c

289

spin_lock(&fs_info->super_lock);

fs/btrfs/fs.c

294

btrfs_info(fs_info,

fs/btrfs/fs.c

298

spin_unlock(&fs_info->super_lock);

fs/btrfs/fs.c

299

set_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags);

fs/btrfs/fs.c

303

void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,

fs/btrfs/fs.c

309

disk_super = fs_info->super_copy;

fs/btrfs/fs.c

312

spin_lock(&fs_info->super_lock);

fs/btrfs/fs.c

317

btrfs_info(fs_info,

fs/btrfs/fs.c

321

spin_unlock(&fs_info->super_lock);

fs/btrfs/fs.c

322

set_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags);

fs/btrfs/fs.c

326

void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,

fs/btrfs/fs.c

332

disk_super = fs_info->super_copy;

fs/btrfs/fs.c

335

spin_lock(&fs_info->super_lock);

fs/btrfs/fs.c

340

btrfs_info(fs_info,

fs/btrfs/fs.c

344

spin_unlock(&fs_info->super_lock);

fs/btrfs/fs.c

345

set_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags);

fs/btrfs/fs.h

1000

static inline void btrfs_set_fs_generation(struct btrfs_fs_info *fs_info, u64 gen)

fs/btrfs/fs.h

1002

WRITE_ONCE(fs_info->generation, gen);

fs/btrfs/fs.h

1005

static inline u64 btrfs_get_last_trans_committed(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1007

return READ_ONCE(fs_info->last_trans_committed);

fs/btrfs/fs.h

1010

static inline void btrfs_set_last_trans_committed(struct btrfs_fs_info *fs_info, u64 gen)

fs/btrfs/fs.h

1012

WRITE_ONCE(fs_info->last_trans_committed, gen);

fs/btrfs/fs.h

1015

static inline void btrfs_set_last_root_drop_gen(struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1018

WRITE_ONCE(fs_info->last_root_drop_gen, gen);

fs/btrfs/fs.h

1021

static inline u64 btrfs_get_last_root_drop_gen(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1023

return READ_ONCE(fs_info->last_root_drop_gen);

fs/btrfs/fs.h

1031

const struct btrfs_fs_info *fs_info, u64 csum_bytes)

fs/btrfs/fs.h

1033

const u64 num_csums = csum_bytes >> fs_info->sectorsize_bits;

fs/btrfs/fs.h

1035

return DIV_ROUND_UP_ULL(num_csums, fs_info->csums_per_leaf);

fs/btrfs/fs.h

1042

static inline u64 btrfs_calc_insert_metadata_size(const struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1045

return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;

fs/btrfs/fs.h

1052

static inline u64 btrfs_calc_metadata_size(const struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1055

return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;

fs/btrfs/fs.h

1058

#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r->fs_info) >> 4) - \

fs/btrfs/fs.h

1061

#define BTRFS_BYTES_TO_BLKS(fs_info, bytes) ((bytes) >> (fs_info)->sectorsize_bits)

fs/btrfs/fs.h

1063

static inline bool btrfs_is_zoned(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1065

return IS_ENABLED(CONFIG_BLK_DEV_ZONED) && fs_info->zone_size > 0;

fs/btrfs/fs.h

1071

static inline u32 count_max_extents(const struct btrfs_fs_info *fs_info, u64 size)

fs/btrfs/fs.h

1074

if (!fs_info)

fs/btrfs/fs.h

1078

return div_u64(size + fs_info->max_extent_size - 1, fs_info->max_extent_size);

fs/btrfs/fs.h

1081

static inline unsigned int btrfs_blocks_per_folio(const struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1084

return folio_size(folio) >> fs_info->sectorsize_bits;

fs/btrfs/fs.h

1088

bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1090

bool btrfs_exclop_start_try_lock(struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1092

void btrfs_exclop_start_unlock(struct btrfs_fs_info *fs_info);

fs/btrfs/fs.h

1093

void btrfs_exclop_finish(struct btrfs_fs_info *fs_info);

fs/btrfs/fs.h

1094

void btrfs_exclop_balance(struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1123

void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,

fs/btrfs/fs.h

1125

void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,

fs/btrfs/fs.h

1127

void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,

fs/btrfs/fs.h

1129

void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,

fs/btrfs/fs.h

1132

#define __btrfs_fs_incompat(fs_info, flags) \

fs/btrfs/fs.h

1133

(!!(btrfs_super_incompat_flags((fs_info)->super_copy) & (flags)))

fs/btrfs/fs.h

1135

#define __btrfs_fs_compat_ro(fs_info, flags) \

fs/btrfs/fs.h

1136

(!!(btrfs_super_compat_ro_flags((fs_info)->super_copy) & (flags)))

fs/btrfs/fs.h

1144

#define btrfs_fs_incompat(fs_info, opt) \

fs/btrfs/fs.h

1145

__btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt)

fs/btrfs/fs.h

1153

#define btrfs_fs_compat_ro(fs_info, opt) \

fs/btrfs/fs.h

1154

__btrfs_fs_compat_ro((fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)

fs/btrfs/fs.h

1159

#define btrfs_test_opt(fs_info, opt) ((fs_info)->mount_opt & \

fs/btrfs/fs.h

1162

static inline bool btrfs_is_full_ro(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1164

if (!sb_rdonly(fs_info->sb))

fs/btrfs/fs.h

1166

if (unlikely(fs_info->mount_opt & BTRFS_MOUNT_FULL_RO_MASK))

fs/btrfs/fs.h

1171

static inline bool btrfs_fs_closing(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1173

return unlikely(test_bit(BTRFS_FS_CLOSING_START, &fs_info->flags));

fs/btrfs/fs.h

1176

static inline bool btrfs_fs_closing_done(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1178

if (btrfs_fs_closing(fs_info) && test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags))

fs/btrfs/fs.h

1192

static inline int btrfs_need_cleaner_sleep(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1194

return test_bit(BTRFS_FS_STATE_RO, &fs_info->fs_state) ||

fs/btrfs/fs.h

1195

btrfs_fs_closing(fs_info);

fs/btrfs/fs.h

1198

static inline void btrfs_wake_unfinished_drop(struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1200

clear_and_wake_up_bit(BTRFS_FS_UNFINISHED_DROPS, &fs_info->flags);

fs/btrfs/fs.h

1203

#define BTRFS_FS_ERROR(fs_info) (READ_ONCE((fs_info)->fs_error))

fs/btrfs/fs.h

1205

#define BTRFS_FS_LOG_CLEANUP_ERROR(fs_info) \

fs/btrfs/fs.h

1207

&(fs_info)->fs_state)))

fs/btrfs/fs.h

1209

static inline bool btrfs_is_shutdown(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1211

return unlikely(test_bit(BTRFS_FS_STATE_EMERGENCY_SHUTDOWN, &fs_info->fs_state));

fs/btrfs/fs.h

1214

static inline void btrfs_force_shutdown(struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1225

WRITE_ONCE(fs_info->fs_error, -EIO);

fs/btrfs/fs.h

1226

if (!test_and_set_bit(BTRFS_FS_STATE_EMERGENCY_SHUTDOWN, &fs_info->fs_state)) {

fs/btrfs/fs.h

1227

btrfs_crit(fs_info, "emergency shutdown");

fs/btrfs/fs.h

1228

fserror_report_shutdown(fs_info->sb, GFP_KERNEL);

fs/btrfs/fs.h

1236

static inline bool btrfs_is_testing(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1238

return unlikely(test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state));

fs/btrfs/fs.h

1247

static inline bool btrfs_is_testing(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

979

#define folio_to_fs_info(_folio) (folio_to_inode(_folio)->root->fs_info)

fs/btrfs/fs.h

982

struct inode *: (_inode)))->root->fs_info)

fs/btrfs/fs.h

990

static inline unsigned int btrfs_min_folio_size(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

992

return 1U << (PAGE_SHIFT + fs_info->block_min_order);

fs/btrfs/fs.h

995

static inline u64 btrfs_get_fs_generation(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

997

return READ_ONCE(fs_info->generation);

fs/btrfs/inode-item.c

299

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode-item.c

356

struct btrfs_super_block *disk_super = fs_info->super_copy;

fs/btrfs/inode-item.c

445

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode-item.c

568

fs_info->sectorsize);

fs/btrfs/inode-item.c

569

clear_start = ALIGN(new_size, fs_info->sectorsize);

fs/btrfs/inode-item.c

615

clear_len = fs_info->sectorsize;

fs/btrfs/inode-item.c

672

if (be_nice && btrfs_check_space_for_delayed_refs(fs_info))

fs/btrfs/inode-item.c

705

ret = btrfs_delayed_refs_rsv_refill(fs_info,

fs/btrfs/inode.c

10004

rb_insert_color(&sp->node, &fs_info->swapfile_pins);

fs/btrfs/inode.c

10005

spin_unlock(&fs_info->swapfile_pins_lock);

fs/btrfs/inode.c

10012

struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;

fs/btrfs/inode.c

10016

spin_lock(&fs_info->swapfile_pins_lock);

fs/btrfs/inode.c

10017

node = rb_first(&fs_info->swapfile_pins);

fs/btrfs/inode.c

10022

rb_erase(&sp->node, &fs_info->swapfile_pins);

fs/btrfs/inode.c

10032

spin_unlock(&fs_info->swapfile_pins_lock);

fs/btrfs/inode.c

10099

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

10135

btrfs_warn(fs_info, "swapfile must not be compressed");

fs/btrfs/inode.c

10140

btrfs_warn(fs_info, "swapfile must not be copy-on-write");

fs/btrfs/inode.c

10145

btrfs_warn(fs_info, "swapfile must not be checksummed");

fs/btrfs/inode.c

1015

btrfs_folio_end_lock(inode->root->fs_info, locked_folio,

fs/btrfs/inode.c

10166

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_SWAP_ACTIVATE)) {

fs/btrfs/inode.c

10167

btrfs_warn(fs_info,

fs/btrfs/inode.c

1017

btrfs_err_rl(inode->root->fs_info,

fs/btrfs/inode.c

10181

btrfs_exclop_finish(fs_info);

fs/btrfs/inode.c

10182

btrfs_warn(fs_info,

fs/btrfs/inode.c

10202

btrfs_exclop_finish(fs_info);

fs/btrfs/inode.c

10203

btrfs_warn(fs_info,

fs/btrfs/inode.c

10212

isize = ALIGN_DOWN(inode->i_size, fs_info->sectorsize);

fs/btrfs/inode.c

10239

btrfs_warn(fs_info, "swapfile must not have holes");

fs/btrfs/inode.c

10255

btrfs_warn(fs_info, "swapfile must not be inline");

fs/btrfs/inode.c

10261

btrfs_warn(fs_info, "swapfile must not be compressed");

fs/btrfs/inode.c

10268

btrfs_warn(fs_info, "swapfile must not have holes");

fs/btrfs/inode.c

10298

btrfs_warn(fs_info,

fs/btrfs/inode.c

10304

map = btrfs_get_chunk_map(fs_info, logical_block_start, len);

fs/btrfs/inode.c

1031

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

10311

btrfs_warn(fs_info,

fs/btrfs/inode.c

10325

btrfs_warn(fs_info, "swapfile must be on one device");

fs/btrfs/inode.c

10335

bg = btrfs_lookup_block_group(fs_info, logical_block_start);

fs/btrfs/inode.c

10337

btrfs_warn(fs_info,

fs/btrfs/inode.c

10344

btrfs_warn(fs_info,

fs/btrfs/inode.c

10347

atomic_read(&fs_info->scrubs_running) ?

fs/btrfs/inode.c

10399

btrfs_exclop_finish(fs_info);

fs/btrfs/inode.c

10472

btrfs_err(root->fs_info,

fs/btrfs/inode.c

1108

btrfs_dec_block_group_reservations(fs_info, ins.objectid);

fs/btrfs/inode.c

1125

btrfs_dec_block_group_reservations(fs_info, ins.objectid);

fs/btrfs/inode.c

1126

btrfs_free_reserved_extent(fs_info, ins.objectid, ins.offset, true);

fs/btrfs/inode.c

1139

btrfs_debug(fs_info,

fs/btrfs/inode.c

1203

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

1267

btrfs_dec_block_group_reservations(fs_info, ins->objectid);

fs/btrfs/inode.c

130

struct btrfs_fs_info *fs_info = warn->fs_info;

fs/btrfs/inode.c

1308

btrfs_dec_block_group_reservations(fs_info, ins->objectid);

fs/btrfs/inode.c

1309

btrfs_free_reserved_extent(fs_info, ins->objectid, ins->offset, true);

fs/btrfs/inode.c

1346

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

1352

u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

1359

if (btrfs_is_shutdown(fs_info)) {

fs/btrfs/inode.c

1371

ASSERT(num_bytes <= btrfs_super_total_bytes(fs_info->super_copy));

fs/btrfs/inode.c

140

local_root = btrfs_get_fs_root(fs_info, root, true);

fs/btrfs/inode.c

1400

min_alloc_size = fs_info->sectorsize;

fs/btrfs/inode.c

1419

ASSERT(btrfs_is_zoned(fs_info));

fs/btrfs/inode.c

1421

wait_on_bit_io(&inode->root->fs_info->flags,

fs/btrfs/inode.c

1506

btrfs_err(fs_info,

fs/btrfs/inode.c

1526

struct btrfs_fs_info *fs_info = btrfs_work_owner(work);

fs/btrfs/inode.c

1555

if (atomic_sub_return(nr_pages, &fs_info->async_delalloc_pages) <

fs/btrfs/inode.c

1557

cond_wake_up_nomb(&fs_info->async_submit_wait);

fs/btrfs/inode.c

1564

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

1640

atomic_add(nr_pages, &fs_info->async_delalloc_pages);

fs/btrfs/inode.c

1642

btrfs_queue_work(fs_info->delalloc_workers, &async_chunk[i].work);

fs/btrfs/inode.c

1724

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

1725

struct btrfs_space_info *sinfo = fs_info->data_sinfo;

fs/btrfs/inode.c

174

btrfs_warn(fs_info,

fs/btrfs/inode.c

1879

csum_root = btrfs_csum_root(root->fs_info, io_start);

fs/btrfs/inode.c

1881

btrfs_err(root->fs_info,

fs/btrfs/inode.c

190

btrfs_warn(fs_info,

fs/btrfs/inode.c

193

fs_info->sectorsize, nlink,

fs/btrfs/inode.c

1960

btrfs_err(inode->root->fs_info,

fs/btrfs/inode.c

1978

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

2008

ASSERT(!btrfs_is_zoned(fs_info) || btrfs_is_data_reloc_root(root));

fs/btrfs/inode.c

201

btrfs_warn(fs_info,

fs/btrfs/inode.c

2010

if (btrfs_is_shutdown(fs_info)) {

fs/btrfs/inode.c

2126

nocow_bg = btrfs_inc_nocow_writers(fs_info,

fs/btrfs/inode.c

218

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

223

const u32 csum_size = fs_info->csum_size;

fs/btrfs/inode.c

2283

btrfs_err(fs_info,

fs/btrfs/inode.c

229

logical = btrfs_get_reloc_bg_bytenr(fs_info);

fs/btrfs/inode.c

2309

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

2313

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

2314

int compress_type = fs_info->compress_type;

fs/btrfs/inode.c

2315

int compress_level = fs_info->compress_level;

fs/btrfs/inode.c

232

btrfs_warn_rl(fs_info, "has data reloc tree but no running relocation");

fs/btrfs/inode.c

233

btrfs_warn_rl(fs_info,

fs/btrfs/inode.c

2394

const bool zoned = btrfs_is_zoned(inode->root->fs_info);

fs/btrfs/inode.c

2403

if (start == 0 && end + 1 <= inode->root->fs_info->sectorsize &&

fs/btrfs/inode.c

243

btrfs_warn_rl(fs_info,

fs/btrfs/inode.c

2435

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

2445

if (size > fs_info->max_extent_size) {

fs/btrfs/inode.c

2454

num_extents = count_max_extents(fs_info, new_size);

fs/btrfs/inode.c

2456

num_extents += count_max_extents(fs_info, new_size);

fs/btrfs/inode.c

2457

if (count_max_extents(fs_info, size) >= num_extents)

fs/btrfs/inode.c

2474

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

2490

if (new_size <= fs_info->max_extent_size) {

fs/btrfs/inode.c

251

ret = extent_from_logical(fs_info, logical, &path, &found_key, &flags);

fs/btrfs/inode.c

2516

num_extents = count_max_extents(fs_info, old_size);

fs/btrfs/inode.c

2518

num_extents += count_max_extents(fs_info, old_size);

fs/btrfs/inode.c

2519

if (count_max_extents(fs_info, new_size) >= num_extents)

fs/btrfs/inode.c

253

btrfs_err_rl(fs_info, "failed to lookup extent item for logical %llu: %d",

fs/btrfs/inode.c

2530

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

2537

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

2539

list_add_tail(&root->delalloc_root, &fs_info->delalloc_roots);

fs/btrfs/inode.c

2540

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

2548

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

2563

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

2566

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

2578

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

2591

u32 num_extents = count_max_extents(fs_info, len);

fs/btrfs/inode.c

2598

if (btrfs_is_testing(fs_info))

fs/btrfs/inode.c

2601

percpu_counter_add_batch(&fs_info->delalloc_bytes, len,

fs/btrfs/inode.c

2602

fs_info->delalloc_batch);

fs/btrfs/inode.c

2635

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

2637

u32 num_extents = count_max_extents(fs_info, len);

fs/btrfs/inode.c

2666

root != fs_info->tree_root)

fs/btrfs/inode.c

2670

if (btrfs_is_testing(fs_info))

fs/btrfs/inode.c

2679

percpu_counter_add_batch(&fs_info->delalloc_bytes, -len,

fs/btrfs/inode.c

2680

fs_info->delalloc_batch);

fs/btrfs/inode.c

270

btrfs_warn_rl(fs_info,

fs/btrfs/inode.c

2725

csum_root = btrfs_csum_root(trans->fs_info,

fs/btrfs/inode.c

2728

btrfs_err(trans->fs_info,

fs/btrfs/inode.c

278

btrfs_warn_rl(fs_info,

fs/btrfs/inode.c

2786

const u32 blocksize = inode->root->fs_info->sectorsize;

fs/btrfs/inode.c

2823

const u32 blocksize = inode->root->fs_info->sectorsize;

fs/btrfs/inode.c

2868

const u64 sectorsize = root->fs_info->sectorsize;

fs/btrfs/inode.c

2952

static void btrfs_release_delalloc_bytes(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

2957

cache = btrfs_lookup_block_group(fs_info, start);

fs/btrfs/inode.c

296

ctx.fs_info = fs_info;

fs/btrfs/inode.c

301

reloc_warn.fs_info = fs_info;

fs/btrfs/inode.c

3012

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

3039

btrfs_lockdep_acquire(fs_info, btrfs_ordered_extent);

fs/btrfs/inode.c

3046

ret = btrfs_zone_finish_endio(fs_info, ordered_extent->disk_bytenr,

fs/btrfs/inode.c

3118

btrfs_zoned_release_data_reloc_bg(fs_info, ordered_extent->disk_bytenr,

fs/btrfs/inode.c

312

const u32 csum_size = root->fs_info->csum_size;

fs/btrfs/inode.c

3125

BUG_ON(root == fs_info->tree_root);

fs/btrfs/inode.c

3132

btrfs_release_delalloc_bytes(fs_info,

fs/btrfs/inode.c

321

btrfs_warn_rl(root->fs_info,

fs/btrfs/inode.c

3229

if (ret && btrfs_test_opt(fs_info, DISCARD_SYNC))

fs/btrfs/inode.c

3230

btrfs_discard_extent(fs_info,

fs/btrfs/inode.c

3234

btrfs_free_reserved_extent(fs_info,

fs/btrfs/inode.c

3241

btrfs_qgroup_free_refroot(fs_info, btrfs_root_id(inode->root),

fs/btrfs/inode.c

3263

if (btrfs_is_zoned(ordered->inode->root->fs_info) &&

fs/btrfs/inode.c

3276

void btrfs_calculate_block_csum_folio(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

3280

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

329

btrfs_warn_rl(root->fs_info,

fs/btrfs/inode.c

3300

return btrfs_calculate_block_csum_pages(fs_info, paddrs, dest);

fs/btrfs/inode.c

3309

void btrfs_calculate_block_csum_pages(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

3312

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

3317

btrfs_csum_init(&csum, fs_info->csum_type);

fs/btrfs/inode.c

3336

int btrfs_check_block_csum(struct btrfs_fs_info *fs_info, phys_addr_t paddr, u8 *csum,

fs/btrfs/inode.c

3339

btrfs_calculate_block_csum_folio(fs_info, paddr, csum);

fs/btrfs/inode.c

3340

if (unlikely(memcmp(csum, csum_expected, fs_info->csum_size) != 0))

fs/btrfs/inode.c

3363

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

3364

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

3384

csum_expected = bbio->csum + (bio_offset >> fs_info->sectorsize_bits) *

fs/btrfs/inode.c

3385

fs_info->csum_size;

fs/btrfs/inode.c

3386

btrfs_calculate_block_csum_pages(fs_info, paddrs, csum);

fs/btrfs/inode.c

3387

if (unlikely(memcmp(csum, csum_expected, fs_info->csum_size) != 0))

fs/btrfs/inode.c

3413

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

3419

WARN_ON_ONCE(test_bit(BTRFS_FS_STATE_NO_DELAYED_IPUT, &fs_info->fs_state));

fs/btrfs/inode.c

3420

atomic_inc(&fs_info->nr_delayed_iputs);

fs/btrfs/inode.c

3426

spin_lock_irqsave(&fs_info->delayed_iput_lock, flags);

fs/btrfs/inode.c

3428

list_add_tail(&inode->delayed_iput, &fs_info->delayed_iputs);

fs/btrfs/inode.c

3429

spin_unlock_irqrestore(&fs_info->delayed_iput_lock, flags);

fs/btrfs/inode.c

3430

if (!test_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags))

fs/btrfs/inode.c

3431

wake_up_process(fs_info->cleaner_kthread);

fs/btrfs/inode.c

3434

static void run_delayed_iput_locked(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

3438

spin_unlock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3440

if (atomic_dec_and_test(&fs_info->nr_delayed_iputs))

fs/btrfs/inode.c

3441

wake_up(&fs_info->delayed_iputs_wait);

fs/btrfs/inode.c

3442

spin_lock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3445

static void btrfs_run_delayed_iput(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

3449

spin_lock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3451

run_delayed_iput_locked(fs_info, inode);

fs/btrfs/inode.c

3452

spin_unlock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3456

void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info)

fs/btrfs/inode.c

3464

spin_lock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3465

while (!list_empty(&fs_info->delayed_iputs)) {

fs/btrfs/inode.c

3468

inode = list_first_entry(&fs_info->delayed_iputs,

fs/btrfs/inode.c

3470

run_delayed_iput_locked(fs_info, inode);

fs/btrfs/inode.c

3472

spin_unlock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3474

spin_lock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3477

spin_unlock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3492

int btrfs_wait_on_delayed_iputs(struct btrfs_fs_info *fs_info)

fs/btrfs/inode.c

3494

int ret = wait_event_killable(fs_info->delayed_iputs_wait,

fs/btrfs/inode.c

3495

atomic_read(&fs_info->nr_delayed_iputs) == 0);

fs/btrfs/inode.c

3535

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

3603

btrfs_err(fs_info,

fs/btrfs/inode.c

3605

ret = BTRFS_FS_ERROR(fs_info) ?: -EINVAL;

fs/btrfs/inode.c

3622

if (!inode && root == fs_info->tree_root) {

fs/btrfs/inode.c

3642

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/inode.c

3643

dead_root = radix_tree_lookup(&fs_info->fs_roots_radix,

fs/btrfs/inode.c

3647

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/inode.c

3696

btrfs_debug(fs_info, "auto deleting %Lu",

fs/btrfs/inode.c

3721

btrfs_debug(fs_info, "unlinked %d orphans", nr_unlink);

fs/btrfs/inode.c

3725

btrfs_err(fs_info, "could not do orphan cleanup %d", ret);

fs/btrfs/inode.c

3809

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

3813

if (btrfs_fs_incompat(fs_info, NO_HOLES))

fs/btrfs/inode.c

3824

btrfs_extent_io_tree_init(fs_info, inode->file_extent_tree,

fs/btrfs/inode.c

3871

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

3954

if (inode->last_trans == btrfs_get_fs_generation(fs_info))

fs/btrfs/inode.c

4026

btrfs_err(fs_info,

fs/btrfs/inode.c

4043

round_up(i_size_read(vfs_inode), fs_info->sectorsize));

fs/btrfs/inode.c

4169

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

4181

&& !test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) {

fs/btrfs/inode.c

4214

if (test_bit(BTRFS_FS_LOG_RECOVERING, &dir->root->fs_info->flags))

fs/btrfs/inode.c

4233

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

4279

btrfs_crit(fs_info,

fs/btrfs/inode.c

4315

btrfs_run_delayed_iput(fs_info, inode);

fs/btrfs/inode.c

4391

btrfs_btree_balance_dirty(BTRFS_I(dir)->root->fs_info);

fs/btrfs/inode.c

444

const u32 sectorsize = trans->fs_info->sectorsize;

fs/btrfs/inode.c

4505

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

4518

dir_id = btrfs_super_root_dir(fs_info->super_copy);

fs/btrfs/inode.c

4519

di = btrfs_lookup_dir_item(NULL, fs_info->tree_root, path,

fs/btrfs/inode.c

4525

btrfs_err(fs_info,

fs/btrfs/inode.c

4537

ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);

fs/btrfs/inode.c

4562

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

4566

if (!BTRFS_FS_ERROR(fs_info))

fs/btrfs/inode.c

4588

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

4597

down_write(&fs_info->subvol_sem);

fs/btrfs/inode.c

4607

btrfs_warn(fs_info,

fs/btrfs/inode.c

4615

btrfs_warn(fs_info,

fs/btrfs/inode.c

4672

fs_info->tree_root,

fs/btrfs/inode.c

4705

btrfs_block_rsv_release(fs_info, &block_rsv, (u64)-1, NULL);

fs/btrfs/inode.c

4717

up_write(&fs_info->subvol_sem);

fs/btrfs/inode.c

4731

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

4739

if (unlikely(btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))) {

fs/btrfs/inode.c

4740

btrfs_err(fs_info,

fs/btrfs/inode.c

4794

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

4875

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

4882

u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

5032

btrfs_folio_set_dirty(fs_info, folio, block_start,

fs/btrfs/inode.c

5062

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

5073

if (btrfs_fs_incompat(fs_info, NO_HOLES))

fs/btrfs/inode.c

5116

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

5120

u64 hole_start = ALIGN(oldsize, fs_info->sectorsize);

fs/btrfs/inode.c

5121

u64 block_end = ALIGN(size, fs_info->sectorsize);

fs/btrfs/inode.c

5150

last_byte = ALIGN(last_byte, fs_info->sectorsize);

fs/btrfs/inode.c

5179

hole_em->generation = btrfs_get_fs_generation(fs_info);

fs/btrfs/inode.c

522

ALIGN(size, root->fs_info->sectorsize));

fs/btrfs/inode.c

5252

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/inode.c

5254

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/inode.c

5256

ALIGN(newsize, fs_info->sectorsize),

fs/btrfs/inode.c

5408

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

5410

u64 delayed_refs_extra = btrfs_calc_delayed_ref_bytes(fs_info, 1);

fs/btrfs/inode.c

5427

ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size + delayed_refs_extra,

fs/btrfs/inode.c

5430

ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size,

fs/btrfs/inode.c

5433

btrfs_warn(fs_info,

fs/btrfs/inode.c

5445

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/inode.c

5455

struct btrfs_fs_info *fs_info;

fs/btrfs/inode.c

5466

fs_info = inode_to_fs_info(inode);

fs/btrfs/inode.c

547

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

5478

if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))

fs/btrfs/inode.c

5503

btrfs_init_metadata_block_rsv(fs_info, &rsv, BTRFS_BLOCK_RSV_TEMP);

fs/btrfs/inode.c

5504

rsv.size = btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/inode.c

5524

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/inode.c

5531

btrfs_btree_balance_dirty_nodelay(fs_info);

fs/btrfs/inode.c

5551

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/inode.c

5556

btrfs_block_rsv_release(fs_info, &rsv, (u64)-1, NULL);

fs/btrfs/inode.c

5610

btrfs_warn(root->fs_info,

fs/btrfs/inode.c

5627

static int fixup_tree_root_location(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

5657

ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);

fs/btrfs/inode.c

567

if (size > fs_info->sectorsize)

fs/btrfs/inode.c

5677

new_root = btrfs_get_fs_root(fs_info, location->objectid, true);

fs/btrfs/inode.c

571

if (data_len >= fs_info->sectorsize)

fs/btrfs/inode.c

5734

if (args->root && args->root == args->root->fs_info->tree_root &&

fs/btrfs/inode.c

575

if (data_len > BTRFS_MAX_INLINE_DATA_SIZE(fs_info))

fs/btrfs/inode.c

5758

inode = iget5_locked_rcu(root->fs_info->sb, hashval, btrfs_find_actor,

fs/btrfs/inode.c

579

if (data_len > fs_info->max_inline)

fs/btrfs/inode.c

5880

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/inode.c

5902

btrfs_crit(fs_info,

fs/btrfs/inode.c

5912

ret = fixup_tree_root_location(fs_info, BTRFS_I(dir), dentry,

fs/btrfs/inode.c

5926

down_read(&fs_info->cleanup_work_sem);

fs/btrfs/inode.c

5929

up_read(&fs_info->cleanup_work_sem);

fs/btrfs/inode.c

6001

btrfs_err(root->fs_info,

fs/btrfs/inode.c

613

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

6252

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

6275

btrfs_balance_delayed_items(fs_info);

fs/btrfs/inode.c

635

drop_args.end = fs_info->sectorsize;

fs/btrfs/inode.c

6432

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/inode.c

6523

if (btrfs_test_opt(fs_info, NODATASUM))

fs/btrfs/inode.c

6525

if (btrfs_test_opt(fs_info, NODATACOW))

fs/btrfs/inode.c

6641

btrfs_err(fs_info,

fs/btrfs/inode.c

678

btrfs_qgroup_free_data(inode, NULL, 0, fs_info->sectorsize, NULL);

fs/btrfs/inode.c

6782

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/inode.c

6811

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

6855

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/inode.c

6927

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

6951

const u32 blocksize = leaf->fs_info->sectorsize;

fs/btrfs/inode.c

6988

const u32 blocksize = path->nodes[0]->fs_info->sectorsize;

fs/btrfs/inode.c

7034

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

7122

btrfs_crit(fs_info,

fs/btrfs/inode.c

7183

ASSERT(em->len == fs_info->sectorsize);

fs/btrfs/inode.c

7198

btrfs_err(fs_info,

fs/btrfs/inode.c

7220

static bool btrfs_extent_readonly(struct btrfs_fs_info *fs_info, u64 bytenr)

fs/btrfs/inode.c

7225

block_group = btrfs_lookup_block_group(fs_info, bytenr);

fs/btrfs/inode.c

7256

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

7316

if (btrfs_extent_readonly(fs_info,

fs/btrfs/inode.c

732

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

7326

root->fs_info->sectorsize) - 1;

fs/btrfs/inode.c

7420

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/inode.c

7423

if (!btrfs_is_subpage(fs_info, folio))

fs/btrfs/inode.c

744

if (end + 1 - start <= fs_info->sectorsize &&

fs/btrfs/inode.c

7486

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

755

if (btrfs_test_opt(fs_info, FORCE_COMPRESS))

fs/btrfs/inode.c

7570

if (!btrfs_folio_test_dirty(fs_info, folio, cur, range_len))

fs/btrfs/inode.c

760

if (btrfs_test_opt(fs_info, COMPRESS) ||

fs/btrfs/inode.c

7634

btrfs_folio_clear_dirty(fs_info, folio, page_start, folio_size(folio));

fs/btrfs/inode.c

7651

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

7655

const u64 min_size = btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/inode.c

7656

const u64 lock_start = round_down(inode->vfs_inode.i_size, fs_info->sectorsize);

fs/btrfs/inode.c

7657

const u64 i_size_up = round_up(inode->vfs_inode.i_size, fs_info->sectorsize);

fs/btrfs/inode.c

7696

btrfs_init_metadata_block_rsv(fs_info, &rsv, BTRFS_BLOCK_RSV_TEMP);

fs/btrfs/inode.c

7711

ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, &rsv,

fs/btrfs/inode.c

7743

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/inode.c

7752

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

7761

btrfs_block_rsv_release(fs_info, &rsv, -1, NULL);

fs/btrfs/inode.c

7762

ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv,

fs/btrfs/inode.c

7783

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

7800

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/inode.c

7808

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

7811

btrfs_block_rsv_release(fs_info, &rsv, (u64)-1, NULL);

fs/btrfs/inode.c

7853

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/inode.c

7887

btrfs_init_metadata_block_rsv(fs_info, &ei->block_rsv,

fs/btrfs/inode.c

789

btrfs_folio_clamp_clear_dirty(inode->root->fs_info, folio, start,

fs/btrfs/inode.c

7902

btrfs_extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO);

fs/btrfs/inode.c

7972

btrfs_err(root->fs_info,

fs/btrfs/inode.c

7977

btrfs_lockdep_acquire(root->fs_info, btrfs_ordered_extent);

fs/btrfs/inode.c

8085

struct btrfs_fs_info *fs_info = inode_to_fs_info(old_dir);

fs/btrfs/inode.c

809

struct btrfs_fs_info *fs_info = cb_to_fs_info(cb);

fs/btrfs/inode.c

810

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/inode.c

8131

down_read(&fs_info->subvol_sem);

fs/btrfs/inode.c

8343

up_read(&fs_info->subvol_sem);

fs/btrfs/inode.c

8370

struct btrfs_fs_info *fs_info = inode_to_fs_info(old_dir);

fs/btrfs/inode.c

8453

down_read(&fs_info->subvol_sem);

fs/btrfs/inode.c

861

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

863

u64 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

8633

up_read(&fs_info->subvol_sem);

fs/btrfs/inode.c

8661

btrfs_btree_balance_dirty(BTRFS_I(new_dir)->root->fs_info);

fs/btrfs/inode.c

872

int compress_type = fs_info->compress_type;

fs/btrfs/inode.c

873

int compress_level = fs_info->compress_level;

fs/btrfs/inode.c

875

if (btrfs_is_shutdown(fs_info))

fs/btrfs/inode.c

8750

btrfs_queue_work(root->fs_info->flush_workers,

fs/btrfs/inode.c

8783

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

8785

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/inode.c

8790

int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, long nr,

fs/btrfs/inode.c

8798

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/inode.c

8801

mutex_lock(&fs_info->delalloc_root_mutex);

fs/btrfs/inode.c

8802

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

8803

list_splice_init(&fs_info->delalloc_roots, &splice);

fs/btrfs/inode.c

8810

&fs_info->delalloc_roots);

fs/btrfs/inode.c

8811

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

8818

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

8820

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

8825

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

8826

list_splice_tail(&splice, &fs_info->delalloc_roots);

fs/btrfs/inode.c

8827

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

8829

mutex_unlock(&fs_info->delalloc_root_mutex);

fs/btrfs/inode.c

8836

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/inode.c

8859

if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(fs_info) ||

fs/btrfs/inode.c

8860

name_len >= fs_info->sectorsize)

fs/btrfs/inode.c

8929

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

9009

btrfs_qgroup_free_refroot(inode->root->fs_info,

fs/btrfs/inode.c

9020

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/inode.c

9068

btrfs_dec_block_group_reservations(fs_info, ins.objectid);

fs/btrfs/inode.c

9071

btrfs_free_reserved_extent(fs_info, ins.objectid,

fs/btrfs/inode.c

9127

range_start = round_down(inode->i_size, fs_info->sectorsize);

fs/btrfs/inode.c

9128

range_end = round_up(i_size, fs_info->sectorsize);

fs/btrfs/inode.c

9204

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/inode.c

9253

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

9262

int btrfs_encoded_io_compression_from_extent(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

9275

if (fs_info->sectorsize < SZ_4K || fs_info->sectorsize > SZ_64K)

fs/btrfs/inode.c

9278

(fs_info->sectorsize_bits - 12);

fs/btrfs/inode.c

9297

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

9331

ret = btrfs_encoded_io_compression_from_extent(fs_info,

fs/btrfs/inode.c

94

struct btrfs_fs_info *fs_info;

fs/btrfs/inode.c

9546

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/inode.c

9566

start = ALIGN_DOWN(iocb->ki_pos, fs_info->sectorsize);

fs/btrfs/inode.c

9662

ret = btrfs_encoded_io_compression_from_extent(fs_info,

fs/btrfs/inode.c

967

total_in = round_up(total_in, fs_info->sectorsize);

fs/btrfs/inode.c

9679

*disk_io_size = ALIGN(*disk_io_size, fs_info->sectorsize);

fs/btrfs/inode.c

9713

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

9722

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/inode.c

9723

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

9746

fs_info->sectorsize_bits)

fs/btrfs/inode.c

9788

if (!IS_ALIGNED(start, fs_info->sectorsize))

fs/btrfs/inode.c

9797

!IS_ALIGNED(start + encoded->len, fs_info->sectorsize))

fs/btrfs/inode.c

9801

if (!IS_ALIGNED(encoded->unencoded_offset, fs_info->sectorsize))

fs/btrfs/inode.c

9804

num_bytes = ALIGN(encoded->len, fs_info->sectorsize);

fs/btrfs/inode.c

9805

ram_bytes = ALIGN(encoded->unencoded_len, fs_info->sectorsize);

fs/btrfs/inode.c

9813

disk_num_bytes = ALIGN(orig_count, fs_info->sectorsize);

fs/btrfs/inode.c

9821

folio = btrfs_alloc_compr_folio(fs_info, GFP_NOFS);

fs/btrfs/inode.c

986

if (!btrfs_test_opt(fs_info, FORCE_COMPRESS) && !inode->prop_compress)

fs/btrfs/inode.c

9922

btrfs_dec_block_group_reservations(fs_info, ins.objectid);

fs/btrfs/inode.c

9936

btrfs_dec_block_group_reservations(fs_info, ins.objectid);

fs/btrfs/inode.c

9937

btrfs_free_reserved_extent(fs_info, ins.objectid, ins.offset, true);

fs/btrfs/inode.c

9971

struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;

fs/btrfs/inode.c

9984

spin_lock(&fs_info->swapfile_pins_lock);

fs/btrfs/inode.c

9985

p = &fs_info->swapfile_pins.rb_node;

fs/btrfs/inode.c

9998

spin_unlock(&fs_info->swapfile_pins_lock);

fs/btrfs/ioctl.c

1024

ret = exclop_start_or_cancel_reloc(fs_info, BTRFS_EXCLOP_RESIZE, cancel);

fs/btrfs/ioctl.c

1041

btrfs_info(fs_info, "resizing devid %llu", devid);

fs/btrfs/ioctl.c

1045

device = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/ioctl.c

1047

btrfs_info(fs_info, "resizer unable to find device %llu",

fs/btrfs/ioctl.c

1054

btrfs_info(fs_info,

fs/btrfs/ioctl.c

1110

new_size = round_down(new_size, fs_info->sectorsize);

fs/btrfs/ioctl.c

1127

btrfs_info(fs_info,

fs/btrfs/ioctl.c

1132

btrfs_exclop_finish(fs_info);

fs/btrfs/ioctl.c

1178

btrfs_info(BTRFS_I(file_inode(file))->root->fs_info,

fs/btrfs/ioctl.c

1252

struct btrfs_fs_info *fs_info = inode_to_fs_info(file_inode(file));

fs/btrfs/ioctl.c

1262

ret = btrfs_qgroup_check_inherit(fs_info, inherit, vol_args->size);

fs/btrfs/ioctl.c

1276

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ioctl.c

1283

down_read(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

1286

up_read(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

1298

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

1327

down_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

1349

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

1363

ret = btrfs_update_root(trans, fs_info->tree_root,

fs/btrfs/ioctl.c

1376

up_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

1536

struct btrfs_fs_info *info = root->fs_info;

fs/btrfs/ioctl.c

1743

struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;

fs/btrfs/ioctl.c

1772

root = btrfs_get_fs_root(fs_info, treeid, true);

fs/btrfs/ioctl.c

1848

ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);

fs/btrfs/ioctl.c

1904

ret = btrfs_search_path_in_tree(root->fs_info,

fs/btrfs/ioctl.c

1960

struct btrfs_fs_info *fs_info;

fs/btrfs/ioctl.c

1975

fs_info = BTRFS_I(inode)->root->fs_info;

fs/btrfs/ioctl.c

1979

root = btrfs_get_fs_root(fs_info, key.objectid, true);

fs/btrfs/ioctl.c

2017

ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);

fs/btrfs/ioctl.c

2022

ret = btrfs_next_leaf(fs_info->tree_root, path);

fs/btrfs/ioctl.c

2158

root = root->fs_info->tree_root;

fs/btrfs/ioctl.c

2225

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/ioctl.c

2237

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/ioctl.c

2238

btrfs_err(fs_info,

fs/btrfs/ioctl.c

2274

dentry = btrfs_get_dentry(fs_info->sb,

fs/btrfs/ioctl.c

2327

fs_info, vol_args2->subvolid);

fs/btrfs/ioctl.c

2385

if (!btrfs_test_opt(fs_info, USER_SUBVOL_RM_ALLOWED))

fs/btrfs/ioctl.c

246

static int check_fsflags_compatible(const struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

249

if (btrfs_is_zoned(fs_info) && (flags & FS_NOCOW_FL))

fs/btrfs/ioctl.c

2514

static long btrfs_ioctl_add_dev(struct btrfs_fs_info *fs_info, void __user *arg)

fs/btrfs/ioctl.c

2523

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/ioctl.c

2524

btrfs_err(fs_info, "device add not supported on extent tree v2 yet");

fs/btrfs/ioctl.c

2528

if (fs_info->fs_devices->temp_fsid) {

fs/btrfs/ioctl.c

2529

btrfs_err(fs_info,

fs/btrfs/ioctl.c

2534

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_DEV_ADD)) {

fs/btrfs/ioctl.c

2535

if (!btrfs_exclop_start_try_lock(fs_info, BTRFS_EXCLOP_DEV_ADD))

fs/btrfs/ioctl.c

2543

fs_info->exclusive_operation = BTRFS_EXCLOP_DEV_ADD;

fs/btrfs/ioctl.c

2544

btrfs_exclop_start_unlock(fs_info);

fs/btrfs/ioctl.c

2558

ret = btrfs_init_new_device(fs_info, vol_args->name);

fs/btrfs/ioctl.c

2561

btrfs_info(fs_info, "disk added %s", vol_args->name);

fs/btrfs/ioctl.c

2565

btrfs_exclop_balance(fs_info, BTRFS_EXCLOP_BALANCE_PAUSED);

fs/btrfs/ioctl.c

2567

btrfs_exclop_finish(fs_info);

fs/btrfs/ioctl.c

2575

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

2602

ret = btrfs_get_dev_args_from_path(fs_info, &args, vol_args->name);

fs/btrfs/ioctl.c

2611

ret = exclop_start_or_cancel_reloc(fs_info, BTRFS_EXCLOP_DEV_REMOVE,

fs/btrfs/ioctl.c

2617

ret = btrfs_rm_device(fs_info, &args, &bdev_file);

fs/btrfs/ioctl.c

2619

btrfs_exclop_finish(fs_info);

fs/btrfs/ioctl.c

2623

btrfs_info(fs_info, "device deleted: id %llu",

fs/btrfs/ioctl.c

2626

btrfs_info(fs_info, "device deleted: %s",

fs/btrfs/ioctl.c

2642

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

2662

ret = btrfs_get_dev_args_from_path(fs_info, &args, vol_args->name);

fs/btrfs/ioctl.c

2671

ret = exclop_start_or_cancel_reloc(fs_info, BTRFS_EXCLOP_DEV_REMOVE,

fs/btrfs/ioctl.c

2674

ret = btrfs_rm_device(fs_info, &args, &bdev_file);

fs/btrfs/ioctl.c

2676

btrfs_info(fs_info, "disk deleted %s", vol_args->name);

fs/btrfs/ioctl.c

2677

btrfs_exclop_finish(fs_info);

fs/btrfs/ioctl.c

2688

static long btrfs_ioctl_fs_info(const struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

2693

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/ioctl.c

2713

fi_args->nodesize = fs_info->nodesize;

fs/btrfs/ioctl.c

2714

fi_args->sectorsize = fs_info->sectorsize;

fs/btrfs/ioctl.c

2715

fi_args->clone_alignment = fs_info->sectorsize;

fs/btrfs/ioctl.c

2718

fi_args->csum_type = btrfs_super_csum_type(fs_info->super_copy);

fs/btrfs/ioctl.c

2719

fi_args->csum_size = btrfs_super_csum_size(fs_info->super_copy);

fs/btrfs/ioctl.c

2724

fi_args->generation = btrfs_get_fs_generation(fs_info);

fs/btrfs/ioctl.c

2740

static long btrfs_ioctl_dev_info(const struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

2757

dev = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/ioctl.c

2784

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

2811

new_root = btrfs_get_fs_root(fs_info, objectid, true);

fs/btrfs/ioctl.c

2833

dir_id = btrfs_super_root_dir(fs_info->super_copy);

fs/btrfs/ioctl.c

2834

di = btrfs_lookup_dir_item(trans, fs_info->tree_root, path,

fs/btrfs/ioctl.c

2843

btrfs_err(fs_info,

fs/btrfs/ioctl.c

2853

btrfs_set_fs_incompat(fs_info, DEFAULT_SUBVOL);

fs/btrfs/ioctl.c

286

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ioctl.c

2878

static long btrfs_ioctl_space_info(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

2908

list_for_each_entry(tmp, &fs_info->space_info, list) {

fs/btrfs/ioctl.c

2961

list_for_each_entry(tmp, &fs_info->space_info, list) {

fs/btrfs/ioctl.c

2990

struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;

fs/btrfs/ioctl.c

3034

transid = btrfs_get_last_trans_committed(root->fs_info);

fs/btrfs/ioctl.c

3046

static noinline long btrfs_ioctl_wait_sync(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3056

return btrfs_wait_for_commit(fs_info, transid);

fs/btrfs/ioctl.c

306

ret = check_fsflags_compatible(fs_info, fsflags);

fs/btrfs/ioctl.c

3061

struct btrfs_fs_info *fs_info = inode_to_fs_info(file_inode(file));

fs/btrfs/ioctl.c

3068

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/ioctl.c

3069

btrfs_err(fs_info, "scrub: extent tree v2 not yet supported");

fs/btrfs/ioctl.c

3086

ret = btrfs_scrub_dev(fs_info, sa->devid, sa->start, sa->end,

fs/btrfs/ioctl.c

3111

static long btrfs_ioctl_scrub_cancel(struct btrfs_fs_info *fs_info)

fs/btrfs/ioctl.c

3116

return btrfs_scrub_cancel(fs_info);

fs/btrfs/ioctl.c

3119

static long btrfs_ioctl_scrub_progress(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3132

ret = btrfs_scrub_progress(fs_info, sa->devid, &sa->progress);

fs/btrfs/ioctl.c

3140

static long btrfs_ioctl_get_dev_stats(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3153

ret = btrfs_get_dev_stats(fs_info, sa);

fs/btrfs/ioctl.c

3161

static long btrfs_ioctl_dev_replace(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3170

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/ioctl.c

3171

btrfs_err(fs_info, "device replace not supported on extent tree v2 yet");

fs/btrfs/ioctl.c

3181

if (sb_rdonly(fs_info->sb))

fs/btrfs/ioctl.c

3183

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_DEV_REPLACE)) {

fs/btrfs/ioctl.c

3186

ret = btrfs_dev_replace_by_ioctl(fs_info, p);

fs/btrfs/ioctl.c

3187

btrfs_exclop_finish(fs_info);

fs/btrfs/ioctl.c

3191

btrfs_dev_replace_status(fs_info, p);

fs/btrfs/ioctl.c

3195

p->result = btrfs_dev_replace_cancel(fs_info);

fs/btrfs/ioctl.c

3268

static long btrfs_ioctl_logical_to_ino(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3304

ret = iterate_inodes_from_logical(loi->logical, fs_info, inodes, ignore_offset);

fs/btrfs/ioctl.c

3318

void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3321

struct btrfs_balance_control *bctl = fs_info->balance_ctl;

fs/btrfs/ioctl.c

3325

if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags))

fs/btrfs/ioctl.c

3327

if (atomic_read(&fs_info->balance_pause_req))

fs/btrfs/ioctl.c

3329

if (atomic_read(&fs_info->balance_cancel_req))

fs/btrfs/ioctl.c

3336

spin_lock(&fs_info->balance_lock);

fs/btrfs/ioctl.c

3338

spin_unlock(&fs_info->balance_lock);

fs/btrfs/ioctl.c

3352

static int btrfs_try_lock_balance(struct btrfs_fs_info *fs_info, bool *excl_acquired)

fs/btrfs/ioctl.c

3363

if (btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE)) {

fs/btrfs/ioctl.c

3365

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3369

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3370

if (fs_info->balance_ctl) {

fs/btrfs/ioctl.c

3372

if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) {

fs/btrfs/ioctl.c

3378

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3383

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3385

if (fs_info->balance_ctl &&

fs/btrfs/ioctl.c

3386

!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) {

fs/btrfs/ioctl.c

3398

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3402

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3410

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ioctl.c

3430

ret = btrfs_try_lock_balance(fs_info, &need_unlock);

fs/btrfs/ioctl.c

3434

lockdep_assert_held(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3437

if (!fs_info->balance_ctl) {

fs/btrfs/ioctl.c

3442

bctl = fs_info->balance_ctl;

fs/btrfs/ioctl.c

3443

spin_lock(&fs_info->balance_lock);

fs/btrfs/ioctl.c

3445

spin_unlock(&fs_info->balance_lock);

fs/btrfs/ioctl.c

3446

btrfs_exclop_balance(fs_info, BTRFS_EXCLOP_BALANCE);

fs/btrfs/ioctl.c

3456

if (fs_info->balance_ctl) {

fs/btrfs/ioctl.c

3481

ret = btrfs_balance(fs_info, bctl, bargs);

fs/btrfs/ioctl.c

3491

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3493

btrfs_exclop_finish(fs_info);

fs/btrfs/ioctl.c

3499

static long btrfs_ioctl_balance_ctl(struct btrfs_fs_info *fs_info, int cmd)

fs/btrfs/ioctl.c

3506

return btrfs_pause_balance(fs_info);

fs/btrfs/ioctl.c

3508

return btrfs_cancel_balance(fs_info);

fs/btrfs/ioctl.c

3514

static long btrfs_ioctl_balance_progress(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3523

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3524

if (!fs_info->balance_ctl) {

fs/btrfs/ioctl.c

3535

btrfs_update_ioctl_balance_args(fs_info, bargs);

fs/btrfs/ioctl.c

3540

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3547

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

3567

down_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

3568

ret = btrfs_quota_enable(fs_info, sa);

fs/btrfs/ioctl.c

3569

up_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

3596

mutex_lock(&fs_info->cleaner_mutex);

fs/btrfs/ioctl.c

3597

down_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

3598

ret = btrfs_quota_disable(fs_info);

fs/btrfs/ioctl.c

3599

up_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

3600

mutex_unlock(&fs_info->cleaner_mutex);

fs/btrfs/ioctl.c

3615

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

3626

if (!btrfs_qgroup_enabled(fs_info))

fs/btrfs/ioctl.c

3666

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/ioctl.c

3668

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/ioctl.c

3670

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

3694

if (!btrfs_qgroup_enabled(root->fs_info))

fs/btrfs/ioctl.c

3755

if (!btrfs_qgroup_enabled(root->fs_info))

fs/btrfs/ioctl.c

3795

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

3802

if (!btrfs_qgroup_enabled(fs_info))

fs/btrfs/ioctl.c

3820

ret = btrfs_qgroup_rescan(fs_info);

fs/btrfs/ioctl.c

3827

static long btrfs_ioctl_quota_rescan_status(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3835

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {

fs/btrfs/ioctl.c

3837

qsa.progress = fs_info->qgroup_rescan_progress.objectid;

fs/btrfs/ioctl.c

3846

static long btrfs_ioctl_quota_rescan_wait(struct btrfs_fs_info *fs_info)

fs/btrfs/ioctl.c

3851

return btrfs_qgroup_wait_for_completion(fs_info, true);

fs/btrfs/ioctl.c

3859

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

387

comp = btrfs_compress_type2str(fs_info->compress_type);

fs/btrfs/ioctl.c

3874

down_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

3899

ret = btrfs_uuid_tree_check_overflow(fs_info, sa->uuid,

fs/btrfs/ioctl.c

3938

ret = btrfs_update_root(trans, fs_info->tree_root,

fs/btrfs/ioctl.c

3957

up_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

4029

static int btrfs_ioctl_get_fslabel(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

4036

spin_lock(&fs_info->super_lock);

fs/btrfs/ioctl.c

4037

memcpy(label, fs_info->super_copy->label, BTRFS_LABEL_SIZE);

fs/btrfs/ioctl.c

4038

spin_unlock(&fs_info->super_lock);

fs/btrfs/ioctl.c

4043

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4056

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

4058

struct btrfs_super_block *super_block = fs_info->super_copy;

fs/btrfs/ioctl.c

4070

btrfs_err(fs_info,

fs/btrfs/ioctl.c

4086

spin_lock(&fs_info->super_lock);

fs/btrfs/ioctl.c

4088

spin_unlock(&fs_info->super_lock);

fs/btrfs/ioctl.c

4115

static int btrfs_ioctl_get_features(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

4118

struct btrfs_super_block *super_block = fs_info->super_copy;

fs/btrfs/ioctl.c

4131

static int check_feature_bits(const struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

4146

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4150

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4160

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4164

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4174

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4178

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4187

#define check_feature(fs_info, change_mask, flags, mask_base) \

fs/btrfs/ioctl.c

4188

check_feature_bits(fs_info, FEAT_##mask_base, change_mask, flags, \

fs/btrfs/ioctl.c

4196

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

4198

struct btrfs_super_block *super_block = fs_info->super_copy;

fs/btrfs/ioctl.c

4215

ret = check_feature(fs_info, flags[0].compat_flags,

fs/btrfs/ioctl.c

4220

ret = check_feature(fs_info, flags[0].compat_ro_flags,

fs/btrfs/ioctl.c

4225

ret = check_feature(fs_info, flags[0].incompat_flags,

fs/btrfs/ioctl.c

4240

spin_lock(&fs_info->super_lock);

fs/btrfs/ioctl.c

4255

spin_unlock(&fs_info->super_lock);

fs/btrfs/ioctl.c

4306

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/ioctl.c

4375

start = ALIGN_DOWN(kiocb.ki_pos, fs_info->sectorsize);

fs/btrfs/ioctl.c

440

static noinline int btrfs_ioctl_fitrim(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

457

if (btrfs_is_zoned(fs_info))

fs/btrfs/ioctl.c

467

if (btrfs_test_opt(fs_info, NOLOGREPLAY))

fs/btrfs/ioctl.c

4693

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/ioctl.c

471

list_for_each_entry_rcu(device, &fs_info->fs_devices->devices,

fs/btrfs/ioctl.c

4785

start = ALIGN_DOWN(pos, fs_info->sectorsize);

fs/btrfs/ioctl.c

491

if (range.len < fs_info->sectorsize)

fs/btrfs/ioctl.c

495

ret = btrfs_trim_fs(fs_info, &range);

fs/btrfs/ioctl.c

4986

static int btrfs_ioctl_subvol_sync(struct btrfs_fs_info *fs_info, void __user *argp)

fs/btrfs/ioctl.c

5005

spin_lock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5006

if (!list_empty(&fs_info->dead_roots)) {

fs/btrfs/ioctl.c

5007

root = list_last_entry(&fs_info->dead_roots,

fs/btrfs/ioctl.c

5012

spin_unlock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5023

spin_lock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5024

args.count = list_count_nodes(&fs_info->dead_roots);

fs/btrfs/ioctl.c

5025

spin_unlock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5030

spin_lock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5032

if (!list_empty(&fs_info->dead_roots)) {

fs/btrfs/ioctl.c

5033

root = list_last_entry(&fs_info->dead_roots,

fs/btrfs/ioctl.c

5039

spin_unlock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5044

spin_lock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5046

if (!list_empty(&fs_info->dead_roots)) {

fs/btrfs/ioctl.c

5047

root = list_first_entry(&fs_info->dead_roots,

fs/btrfs/ioctl.c

5053

spin_unlock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5067

if (down_read_interruptible(&fs_info->subvol_sem) == -EINTR)

fs/btrfs/ioctl.c

5070

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/ioctl.c

5071

root = radix_tree_lookup(&fs_info->fs_roots_radix,

fs/btrfs/ioctl.c

5079

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/ioctl.c

5080

up_read(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

5113

static int btrfs_ioctl_shutdown(struct btrfs_fs_info *fs_info, unsigned long arg)

fs/btrfs/ioctl.c

5127

if (btrfs_is_shutdown(fs_info))

fs/btrfs/ioctl.c

5133

ret = freeze_super(fs_info->sb, FREEZE_HOLDER_KERNEL, NULL);

fs/btrfs/ioctl.c

5136

btrfs_force_shutdown(fs_info);

fs/btrfs/ioctl.c

5137

ret = thaw_super(fs_info->sb, FREEZE_HOLDER_KERNEL, NULL);

fs/btrfs/ioctl.c

5142

btrfs_force_shutdown(fs_info);

fs/btrfs/ioctl.c

5153

static int copy_csums_to_user(struct btrfs_fs_info *fs_info, u64 disk_bytenr,

fs/btrfs/ioctl.c

5159

const u32 csum_size = fs_info->csum_size;

fs/btrfs/ioctl.c

5162

csum_root = btrfs_csum_root(fs_info, disk_bytenr);

fs/btrfs/ioctl.c

5164

btrfs_err(fs_info, "missing csum root for extent at bytenr %llu", disk_bytenr);

fs/btrfs/ioctl.c

5181

offset = ((sums->logical - disk_bytenr) >> fs_info->sectorsize_bits) * csum_size;

fs/btrfs/ioctl.c

5182

copy_size = (sums->len >> fs_info->sectorsize_bits) * csum_size;

fs/btrfs/ioctl.c

5206

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/ioctl.c

5211

const u32 csum_size = fs_info->csum_size;

fs/btrfs/ioctl.c

5230

if (!IS_ALIGNED(args.offset, fs_info->sectorsize) ||

fs/btrfs/ioctl.c

5231

!IS_ALIGNED(args.length, fs_info->sectorsize))

fs/btrfs/ioctl.c

534

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/ioctl.c

5414

entry_csum_size = (range_len >> fs_info->sectorsize_bits) * csum_size;

fs/btrfs/ioctl.c

5434

ret = copy_csums_to_user(fs_info,

fs/btrfs/ioctl.c

5491

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

5499

return btrfs_ioctl_get_fslabel(fs_info, argp);

fs/btrfs/ioctl.c

5503

return btrfs_ioctl_fitrim(fs_info, argp);

fs/btrfs/ioctl.c

5529

return btrfs_ioctl_add_dev(fs_info, argp);

fs/btrfs/ioctl.c

5535

return btrfs_ioctl_fs_info(fs_info, argp);

fs/btrfs/ioctl.c

5537

return btrfs_ioctl_dev_info(fs_info, argp);

fs/btrfs/ioctl.c

5547

return btrfs_ioctl_logical_to_ino(fs_info, argp, 1);

fs/btrfs/ioctl.c

5549

return btrfs_ioctl_logical_to_ino(fs_info, argp, 2);

fs/btrfs/ioctl.c

5551

return btrfs_ioctl_space_info(fs_info, argp);

fs/btrfs/ioctl.c

5555

ret = btrfs_start_delalloc_roots(fs_info, LONG_MAX, false);

fs/btrfs/ioctl.c

5563

wake_up_process(fs_info->cleaner_kthread);

fs/btrfs/ioctl.c

5569

return btrfs_ioctl_wait_sync(fs_info, argp);

fs/btrfs/ioctl.c

5573

return btrfs_ioctl_scrub_cancel(fs_info);

fs/btrfs/ioctl.c

5575

return btrfs_ioctl_scrub_progress(fs_info, argp);

fs/btrfs/ioctl.c

5579

return btrfs_ioctl_balance_ctl(fs_info, arg);

fs/btrfs/ioctl.c

5581

return btrfs_ioctl_balance_progress(fs_info, argp);

fs/btrfs/ioctl.c

559

ret = btrfs_get_free_objectid(fs_info->tree_root, &objectid);

fs/btrfs/ioctl.c

5595

return btrfs_ioctl_get_dev_stats(fs_info, argp);

fs/btrfs/ioctl.c

5607

return btrfs_ioctl_quota_rescan_status(fs_info, argp);

fs/btrfs/ioctl.c

5609

return btrfs_ioctl_quota_rescan_wait(fs_info);

fs/btrfs/ioctl.c

5611

return btrfs_ioctl_dev_replace(fs_info, argp);

fs/btrfs/ioctl.c

5615

return btrfs_ioctl_get_features(fs_info, argp);

fs/btrfs/ioctl.c

5645

return btrfs_ioctl_subvol_sync(fs_info, argp);

fs/btrfs/ioctl.c

5647

return btrfs_ioctl_shutdown(fs_info, arg);

fs/btrfs/ioctl.c

619

fs_info->nodesize);

fs/btrfs/ioctl.c

649

ret = btrfs_insert_root(trans, fs_info->tree_root, &key,

fs/btrfs/ioctl.c

674

new_root = btrfs_get_new_fs_root(fs_info, objectid, &anon_dev);

fs/btrfs/ioctl.c

721

btrfs_block_rsv_release(fs_info, &block_rsv, (u64)-1, NULL);

fs/btrfs/ioctl.c

739

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/ioctl.c

749

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/ioctl.c

750

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

762

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

842

btrfs_block_rsv_release(fs_info, block_rsv, (u64)-1, NULL);

fs/btrfs/ioctl.c

866

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/ioctl.c

887

down_read(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

900

up_read(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

953

static int exclop_start_or_cancel_reloc(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

958

if (!btrfs_exclop_start(fs_info, type))

fs/btrfs/ioctl.c

965

if (btrfs_exclop_start_try_lock(fs_info, type)) {

fs/btrfs/ioctl.c

971

atomic_inc(&fs_info->reloc_cancel_req);

fs/btrfs/ioctl.c

972

btrfs_exclop_start_unlock(fs_info);

fs/btrfs/ioctl.c

974

if (test_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags))

fs/btrfs/ioctl.c

975

wait_on_bit(&fs_info->flags, BTRFS_FS_RELOC_RUNNING,

fs/btrfs/ioctl.c

990

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ioctl.h

24

void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info,

fs/btrfs/lzo.c

176

static int copy_compressed_data_to_bio(struct btrfs_fs_info *fs_info,

fs/btrfs/lzo.c

183

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/lzo.c

184

const u32 sectorsize_bits = fs_info->sectorsize_bits;

fs/btrfs/lzo.c

185

const u32 fsize = btrfs_min_folio_size(fs_info);

fs/btrfs/lzo.c

205

*out_folio = btrfs_alloc_compr_folio(fs_info, GFP_NOFS);

fs/btrfs/lzo.c

232

*out_folio = btrfs_alloc_compr_folio(fs_info, GFP_NOFS);

fs/btrfs/lzo.c

263

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/lzo.c

268

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/lzo.c

269

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/lzo.c

283

folio_out = btrfs_alloc_compr_folio(fs_info, GFP_NOFS);

fs/btrfs/lzo.c

319

ret = copy_compressed_data_to_bio(fs_info, bio, workspace->cbuf, out_len,

fs/btrfs/lzo.c

370

struct btrfs_fs_info *fs_info = cb_to_fs_info(cb);

fs/btrfs/lzo.c

371

const u32 min_folio_shift = PAGE_SHIFT + fs_info->block_min_order;

fs/btrfs/lzo.c

416

struct btrfs_fs_info *fs_info = cb->bbio.inode->root->fs_info;

fs/btrfs/lzo.c

417

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/lzo.c

435

ASSERT(folio_size(fi.folio) == btrfs_min_folio_size(fs_info));

fs/btrfs/lzo.c

452

btrfs_err(fs_info,

fs/btrfs/lzo.c

480

if (unlikely(seg_len > workspace_cbuf_length(fs_info))) {

fs/btrfs/lzo.c

487

btrfs_err(fs_info,

fs/btrfs/lzo.c

498

btrfs_err(fs_info,

fs/btrfs/lzo.c

515

btrfs_err(fs_info,

fs/btrfs/lzo.c

548

struct btrfs_fs_info *fs_info = folio_to_fs_info(dest_folio);

fs/btrfs/lzo.c

549

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/lzo.c

552

size_t max_segment_len = workspace_buf_length(fs_info);

fs/btrfs/lzo.c

556

btrfs_err(fs_info, "invalid lzo header length, has %zu expect (%u, %zu)",

fs/btrfs/lzo.c

563

btrfs_err(fs_info, "invalid lzo header length, has %zu expect %zu",

fs/btrfs/lzo.c

571

btrfs_err(fs_info, "invalid lzo segment length, has %zu expect %zu",

fs/btrfs/lzo.c

582

btrfs_err(fs_info,

fs/btrfs/lzo.c

68

static u32 workspace_buf_length(const struct btrfs_fs_info *fs_info)

fs/btrfs/lzo.c

70

return lzo1x_worst_compress(fs_info->sectorsize);

fs/btrfs/lzo.c

72

static u32 workspace_cbuf_length(const struct btrfs_fs_info *fs_info)

fs/btrfs/lzo.c

74

return lzo1x_worst_compress(fs_info->sectorsize);

fs/btrfs/lzo.c

87

struct list_head *lzo_alloc_workspace(struct btrfs_fs_info *fs_info)

fs/btrfs/lzo.c

96

workspace->buf = kvmalloc(workspace_buf_length(fs_info), GFP_KERNEL | __GFP_NOWARN);

fs/btrfs/lzo.c

97

workspace->cbuf = kvmalloc(workspace_cbuf_length(fs_info), GFP_KERNEL | __GFP_NOWARN);

fs/btrfs/messages.c

118

void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,

fs/btrfs/messages.c

121

struct super_block *sb = fs_info->sb;

fs/btrfs/messages.c

141

btrfs_state_to_string(fs_info, statestr);

fs/btrfs/messages.c

163

WRITE_ONCE(fs_info->fs_error, error);

fs/btrfs/messages.c

172

btrfs_discard_stop(fs_info);

fs/btrfs/messages.c

176

btrfs_info(fs_info, "forced readonly");

fs/btrfs/messages.c

215

void _btrfs_printk(const struct btrfs_fs_info *fs_info, unsigned int level, const char *fmt, ...)

fs/btrfs/messages.c

232

if (fs_info) {

fs/btrfs/messages.c

235

btrfs_state_to_string(fs_info, statestr);

fs/btrfs/messages.c

237

fs_info->sb->s_id, statestr, &vaf);

fs/btrfs/messages.c

248

void __cold btrfs_warn_32bit_limit(struct btrfs_fs_info *fs_info)

fs/btrfs/messages.c

250

if (!test_and_set_bit(BTRFS_FS_32BIT_WARN, &fs_info->flags)) {

fs/btrfs/messages.c

251

btrfs_warn(fs_info, "reaching 32bit limit for logical addresses");

fs/btrfs/messages.c

252

btrfs_warn(fs_info,

fs/btrfs/messages.c

255

btrfs_warn(fs_info,

fs/btrfs/messages.c

260

void __cold btrfs_err_32bit_limit(struct btrfs_fs_info *fs_info)

fs/btrfs/messages.c

262

if (!test_and_set_bit(BTRFS_FS_32BIT_ERROR, &fs_info->flags)) {

fs/btrfs/messages.c

263

btrfs_err(fs_info, "reached 32bit limit for logical addresses");

fs/btrfs/messages.c

264

btrfs_err(fs_info,

fs/btrfs/messages.c

267

btrfs_err(fs_info,

fs/btrfs/messages.c

278

void __btrfs_panic(const struct btrfs_fs_info *fs_info, const char *function,

fs/btrfs/messages.c

286

if (fs_info)

fs/btrfs/messages.c

287

s_id = fs_info->sb->s_id;

fs/btrfs/messages.c

293

if (fs_info && (btrfs_test_opt(fs_info, PANIC_ON_FATAL_ERROR)))

fs/btrfs/messages.c

297

btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)",

fs/btrfs/messages.h

171

void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,

fs/btrfs/messages.h

176

#define btrfs_handle_fs_error(fs_info, error, fmt, args...) \

fs/btrfs/messages.h

177

__btrfs_handle_fs_error((fs_info), __func__, __LINE__, \

fs/btrfs/messages.h

18

void btrfs_no_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)

fs/btrfs/messages.h

182

void __btrfs_panic(const struct btrfs_fs_info *fs_info, const char *function,

fs/btrfs/messages.h

188

#define btrfs_panic(fs_info, error, fmt, args...) \

fs/btrfs/messages.h

190

__btrfs_panic(fs_info, __func__, __LINE__, error, fmt, ##args); \

fs/btrfs/messages.h

203

void btrfs_warn_32bit_limit(struct btrfs_fs_info *fs_info);

fs/btrfs/messages.h

204

void btrfs_err_32bit_limit(struct btrfs_fs_info *fs_info);

fs/btrfs/messages.h

27

void _btrfs_printk(const struct btrfs_fs_info *fs_info, unsigned int level, const char *fmt, ...);

fs/btrfs/messages.h

31

#define btrfs_printk_in_rcu(fs_info, level, fmt, args...) \

fs/btrfs/messages.h

32

btrfs_no_printk(fs_info, fmt, ##args)

fs/btrfs/messages.h

34

#define btrfs_printk_rl_in_rcu(fs_info, level, fmt, args...) \

fs/btrfs/messages.h

35

btrfs_no_printk(fs_info, fmt, ##args)

fs/btrfs/messages.h

42

#define btrfs_crit(fs_info, fmt, args...) \

fs/btrfs/messages.h

43

btrfs_printk_in_rcu(fs_info, LOGLEVEL_CRIT, fmt, ##args)

fs/btrfs/messages.h

44

#define btrfs_err(fs_info, fmt, args...) \

fs/btrfs/messages.h

45

btrfs_printk_in_rcu(fs_info, LOGLEVEL_ERR, fmt, ##args)

fs/btrfs/messages.h

46

#define btrfs_warn(fs_info, fmt, args...) \

fs/btrfs/messages.h

47

btrfs_printk_in_rcu(fs_info, LOGLEVEL_WARNING, fmt, ##args)

fs/btrfs/messages.h

48

#define btrfs_info(fs_info, fmt, args...) \

fs/btrfs/messages.h

49

btrfs_printk_in_rcu(fs_info, LOGLEVEL_INFO, fmt, ##args)

fs/btrfs/messages.h

54

#define btrfs_crit_rl(fs_info, fmt, args...) \

fs/btrfs/messages.h

55

btrfs_printk_rl_in_rcu(fs_info, LOGLEVEL_CRIT, fmt, ##args)

fs/btrfs/messages.h

56

#define btrfs_err_rl(fs_info, fmt, args...) \

fs/btrfs/messages.h

57

btrfs_printk_rl_in_rcu(fs_info, LOGLEVEL_ERR, fmt, ##args)

fs/btrfs/messages.h

58

#define btrfs_warn_rl(fs_info, fmt, args...) \

fs/btrfs/messages.h

59

btrfs_printk_rl_in_rcu(fs_info, LOGLEVEL_WARNING, fmt, ##args)

fs/btrfs/messages.h

60

#define btrfs_info_rl(fs_info, fmt, args...) \

fs/btrfs/messages.h

61

btrfs_printk_rl_in_rcu(fs_info, LOGLEVEL_INFO, fmt, ##args)

fs/btrfs/messages.h

64

#define btrfs_debug(fs_info, fmt, args...) \

fs/btrfs/messages.h

66

fs_info, LOGLEVEL_DEBUG, fmt, ##args)

fs/btrfs/messages.h

67

#define btrfs_debug_rl(fs_info, fmt, args...) \

fs/btrfs/messages.h

69

fs_info, LOGLEVEL_DEBUG, fmt, ##args)

fs/btrfs/messages.h

71

#define btrfs_debug(fs_info, fmt, args...) \

fs/btrfs/messages.h

72

btrfs_printk_in_rcu(fs_info, LOGLEVEL_DEBUG, fmt, ##args)

fs/btrfs/messages.h

73

#define btrfs_debug_rl(fs_info, fmt, args...) \

fs/btrfs/messages.h

74

btrfs_printk_rl_in_rcu(fs_info, LOGLEVEl_DEBUG, fmt, ##args)

fs/btrfs/messages.h

77

#define btrfs_debug(fs_info, fmt, args...) do { (void)(fs_info); } while(0)

fs/btrfs/messages.h

78

#define btrfs_debug_rl(fs_info, fmt, args...) do { (void)(fs_info); } while(0)

fs/btrfs/messages.h

83

#define btrfs_printk_in_rcu(fs_info, level, fmt, args...) \

fs/btrfs/messages.h

86

_btrfs_printk(fs_info, level, fmt, ##args); \

fs/btrfs/messages.h

90

#define btrfs_printk_rl_in_rcu(fs_info, level, fmt, args...) \

fs/btrfs/messages.h

98

_btrfs_printk(fs_info, level, fmt, ##args); \

fs/btrfs/ordered-data.c

1243

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ordered-data.c

1270

const int fs_error = BTRFS_FS_ERROR(fs_info);

fs/btrfs/ordered-data.c

1348

btrfs_panic(fs_info, -EEXIST,

fs/btrfs/ordered-data.c

232

btrfs_qgroup_free_refroot(inode->root->fs_info,

fs/btrfs/ordered-data.c

243

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ordered-data.c

248

percpu_counter_add_batch(&fs_info->ordered_bytes, entry->num_bytes,

fs/btrfs/ordered-data.c

249

fs_info->delalloc_batch);

fs/btrfs/ordered-data.c

261

btrfs_panic(fs_info, -EEXIST,

fs/btrfs/ordered-data.c

273

spin_lock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

275

list_add_tail(&root->ordered_root, &fs_info->ordered_roots);

fs/btrfs/ordered-data.c

276

spin_unlock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

385

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/ordered-data.c

391

btrfs_crit(fs_info,

fs/btrfs/ordered-data.c

421

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/ordered-data.c

423

fs_info->endio_freespace_worker : fs_info->endio_write_workers;

fs/btrfs/ordered-data.c

602

btrfs_crit(inode->root->fs_info,

fs/btrfs/ordered-data.c

657

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ordered-data.c

668

btrfs_lockdep_acquire(fs_info, btrfs_trans_pending_ordered);

fs/btrfs/ordered-data.c

673

if (root != fs_info->tree_root) {

fs/btrfs/ordered-data.c

685

percpu_counter_add_batch(&fs_info->ordered_bytes, -entry->num_bytes,

fs/btrfs/ordered-data.c

686

fs_info->delalloc_batch);

fs/btrfs/ordered-data.c

711

spin_lock(&fs_info->trans_lock);

fs/btrfs/ordered-data.c

712

trans = fs_info->running_transaction;

fs/btrfs/ordered-data.c

715

spin_unlock(&fs_info->trans_lock);

fs/btrfs/ordered-data.c

717

ASSERT(trans || BTRFS_FS_ERROR(fs_info));

fs/btrfs/ordered-data.c

725

btrfs_lockdep_release(fs_info, btrfs_trans_pending_ordered);

fs/btrfs/ordered-data.c

734

spin_lock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

737

spin_unlock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

742

btrfs_lockdep_release(fs_info, btrfs_ordered_extent);

fs/btrfs/ordered-data.c

761

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ordered-data.c

801

btrfs_queue_work(fs_info->flush_workers, &ordered->flush_work);

fs/btrfs/ordered-data.c

828

void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, u64 nr,

fs/btrfs/ordered-data.c

835

mutex_lock(&fs_info->ordered_operations_mutex);

fs/btrfs/ordered-data.c

836

spin_lock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

837

list_splice_init(&fs_info->ordered_roots, &splice);

fs/btrfs/ordered-data.c

844

&fs_info->ordered_roots);

fs/btrfs/ordered-data.c

845

spin_unlock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

853

spin_lock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

855

list_splice_tail(&splice, &fs_info->ordered_roots);

fs/btrfs/ordered-data.c

856

spin_unlock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

857

mutex_unlock(&fs_info->ordered_operations_mutex);

fs/btrfs/ordered-data.c

903

btrfs_might_wait_for_event(inode->root->fs_info, btrfs_ordered_extent);

fs/btrfs/ordered-data.h

219

void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, u64 nr,

fs/btrfs/print-tree.c

117

btrfs_err(eb->fs_info,

fs/btrfs/print-tree.c

161

if (!IS_ALIGNED(offset, eb->fs_info->sectorsize))

fs/btrfs/print-tree.c

164

offset, eb->fs_info->sectorsize);

fs/btrfs/print-tree.c

178

if (!IS_ALIGNED(offset, eb->fs_info->sectorsize))

fs/btrfs/print-tree.c

181

offset, eb->fs_info->sectorsize);

fs/btrfs/print-tree.c

201

btrfs_warn(l->fs_info, "uuid item with illegal size %lu",

fs/btrfs/print-tree.c

233

btrfs_info(eb->fs_info, "refs %u lock_owner %u current %u",

fs/btrfs/print-tree.c

337

const struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/print-tree.c

339

const u32 csum_bytes = (size / fs_info->csum_size) * fs_info->sectorsize;

fs/btrfs/print-tree.c

434

struct btrfs_fs_info *fs_info;

fs/btrfs/print-tree.c

448

fs_info = l->fs_info;

fs/btrfs/print-tree.c

451

btrfs_info(fs_info,

fs/btrfs/print-tree.c

588

struct btrfs_fs_info *fs_info;

fs/btrfs/print-tree.c

595

fs_info = c->fs_info;

fs/btrfs/print-tree.c

602

btrfs_info(fs_info,

fs/btrfs/print-tree.c

605

nr, (u32)BTRFS_NODEPTRS_PER_BLOCK(fs_info) - nr,

fs/btrfs/print-tree.c

626

next = read_tree_block(fs_info, btrfs_node_blockptr(c, i), &check);

fs/btrfs/print-tree.c

97

ASSERT(btrfs_fs_incompat(eb->fs_info, SIMPLE_QUOTA));

fs/btrfs/props.c

278

btrfs_warn(root->fs_info,

fs/btrfs/props.c

317

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/props.c

340

btrfs_set_fs_incompat(fs_info, COMPRESS_LZO);

fs/btrfs/props.c

345

btrfs_set_fs_incompat(fs_info, COMPRESS_ZSTD);

fs/btrfs/props.c

403

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/props.c

442

num_bytes = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/props.c

443

ret = btrfs_block_rsv_add(fs_info, trans->block_rsv,

fs/btrfs/props.c

462

btrfs_block_rsv_release(fs_info, trans->block_rsv,

fs/btrfs/qgroup.c

1001

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/qgroup.c

1020

lockdep_assert_held_write(&fs_info->subvol_sem);

fs/btrfs/qgroup.c

1022

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/qgroup.c

1023

btrfs_err(fs_info,

fs/btrfs/qgroup.c

1028

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1029

if (fs_info->quota_root)

fs/btrfs/qgroup.c

1032

ret = btrfs_sysfs_add_qgroups(fs_info);

fs/btrfs/qgroup.c

1049

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1061

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1068

if (fs_info->quota_root)

fs/btrfs/qgroup.c

108

static void qgroup_rsv_add_by_qgroup(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

1104

fs_info->qgroup_flags = BTRFS_QGROUP_STATUS_FLAG_ON;

fs/btrfs/qgroup.c

1106

fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE;

fs/btrfs/qgroup.c

1107

btrfs_set_fs_incompat(fs_info, SIMPLE_QUOTA);

fs/btrfs/qgroup.c

1116

fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;

fs/btrfs/qgroup.c

1118

btrfs_set_qgroup_status_flags(leaf, ptr, fs_info->qgroup_flags &

fs/btrfs/qgroup.c

115

qgroup_rsv_add(fs_info, dest, src->rsv.values[i], i);

fs/btrfs/qgroup.c

1161

qgroup = add_qgroup_rb(fs_info, prealloc, found_key.offset);

fs/btrfs/qgroup.c

1163

ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

118

static void qgroup_rsv_release_by_qgroup(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

1209

qgroup = add_qgroup_rb(fs_info, prealloc, BTRFS_FS_TREE_OBJECTID);

fs/btrfs/qgroup.c

1211

ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

1223

fs_info->qgroup_enable_gen = trans->transid + 1;

fs/btrfs/qgroup.c

1224

set_bit(BTRFS_FS_SQUOTA_ENABLING, &fs_info->flags);

fs/btrfs/qgroup.c

1227

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1240

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1243

clear_bit(BTRFS_FS_SQUOTA_ENABLING, &fs_info->flags);

fs/btrfs/qgroup.c

1244

fs_info->qgroup_enable_gen = 0;

fs/btrfs/qgroup.c

125

qgroup_rsv_release(fs_info, dest, src->rsv.values[i], i);

fs/btrfs/qgroup.c

1254

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1255

fs_info->quota_root = quota_root;

fs/btrfs/qgroup.c

1256

set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);

fs/btrfs/qgroup.c

1258

clear_bit(BTRFS_FS_SQUOTA_ENABLING, &fs_info->flags);

fs/btrfs/qgroup.c

1259

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1262

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

1265

ret = qgroup_rescan_init(fs_info, 0, 1);

fs/btrfs/qgroup.c

1267

qgroup_rescan_zero_tracking(fs_info);

fs/btrfs/qgroup.c

1268

fs_info->qgroup_rescan_running = true;

fs/btrfs/qgroup.c

1269

btrfs_queue_work(fs_info->qgroup_rescan_workers,

fs/btrfs/qgroup.c

1270

&fs_info->qgroup_rescan_work);

fs/btrfs/qgroup.c

1295

btrfs_sysfs_del_qgroups(fs_info);

fs/btrfs/qgroup.c

1296

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1320

static int flush_reservations(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

1324

ret = btrfs_start_delalloc_roots(fs_info, LONG_MAX, false);

fs/btrfs/qgroup.c

1327

btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);

fs/btrfs/qgroup.c

1329

return btrfs_commit_current_transaction(fs_info->tree_root);

fs/btrfs/qgroup.c

1332

int btrfs_quota_disable(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

1342

lockdep_assert_held_write(&fs_info->subvol_sem);

fs/btrfs/qgroup.c

1348

lockdep_assert_held(&fs_info->cleaner_mutex);

fs/btrfs/qgroup.c

1350

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1351

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

1360

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1367

clear_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);

fs/btrfs/qgroup.c

1368

btrfs_qgroup_wait_for_completion(fs_info, false);

fs/btrfs/qgroup.c

1375

ret = flush_reservations(fs_info);

fs/btrfs/qgroup.c

1377

set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);

fs/btrfs/qgroup.c

1390

trans = btrfs_start_transaction(fs_info->tree_root, 1);

fs/btrfs/qgroup.c

1392

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1396

set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);

fs/btrfs/qgroup.c

1400

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

1403

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1404

quota_root = fs_info->quota_root;

fs/btrfs/qgroup.c

1405

fs_info->quota_root = NULL;

fs/btrfs/qgroup.c

1406

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_ON;

fs/btrfs/qgroup.c

1407

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE;

fs/btrfs/qgroup.c

1408

fs_info->qgroup_drop_subtree_thres = BTRFS_QGROUP_DROP_SUBTREE_THRES_DEFAULT;

fs/btrfs/qgroup.c

1409

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1411

btrfs_free_qgroup_config(fs_info);

fs/btrfs/qgroup.c

1425

spin_lock(&fs_info->trans_lock);

fs/btrfs/qgroup.c

1427

spin_unlock(&fs_info->trans_lock);

fs/btrfs/qgroup.c

1440

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1448

static void qgroup_dirty(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

1452

list_add(&qgroup->dirty, &fs_info->dirty_qgroups);

fs/btrfs/qgroup.c

1487

static int __qgroup_excl_accounting(struct btrfs_fs_info *fs_info, u64 ref_root,

fs/btrfs/qgroup.c

1496

qgroup = find_qgroup_rb(fs_info, ref_root);

fs/btrfs/qgroup.c

1513

qgroup_rsv_add_by_qgroup(fs_info, qgroup, src);

fs/btrfs/qgroup.c

1515

qgroup_rsv_release_by_qgroup(fs_info, qgroup, src);

fs/btrfs/qgroup.c

1516

qgroup_dirty(fs_info, qgroup);

fs/btrfs/qgroup.c

1540

static int quick_update_accounting(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

1546

qgroup = find_qgroup_rb(fs_info, src);

fs/btrfs/qgroup.c

1550

ret = __qgroup_excl_accounting(fs_info, dst, qgroup, sign);

fs/btrfs/qgroup.c

1557

fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;

fs/btrfs/qgroup.c

1568

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

1582

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1583

if (!fs_info->quota_root) {

fs/btrfs/qgroup.c

1587

member = find_qgroup_rb(fs_info, src);

fs/btrfs/qgroup.c

1588

parent = find_qgroup_rb(fs_info, dst);

fs/btrfs/qgroup.c

159

qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid,

fs/btrfs/qgroup.c

161

static void qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info);

fs/btrfs/qgroup.c

1612

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1616

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1619

ret = quick_update_accounting(fs_info, src, dst, 1);

fs/btrfs/qgroup.c

1620

squota_check_parent_usage(fs_info, parent);

fs/btrfs/qgroup.c

1621

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1624

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1631

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

1639

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

1642

member = find_qgroup_rb(fs_info, src);

fs/btrfs/qgroup.c

1643

parent = find_qgroup_rb(fs_info, dst);

fs/btrfs/qgroup.c

1672

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1673

del_relation_rb(fs_info, src, dst);

fs/btrfs/qgroup.c

1674

ret = quick_update_accounting(fs_info, src, dst, -1);

fs/btrfs/qgroup.c

1676

squota_check_parent_usage(fs_info, parent);

fs/btrfs/qgroup.c

1677

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1686

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

1689

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1691

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1698

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

1704

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1705

if (!fs_info->quota_root) {

fs/btrfs/qgroup.c

1709

quota_root = fs_info->quota_root;

fs/btrfs/qgroup.c

1710

qgroup = find_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

1726

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1727

qgroup = add_qgroup_rb(fs_info, prealloc, qgroupid);

fs/btrfs/qgroup.c

1728

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1731

ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

1733

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1738

static bool can_delete_parent_qgroup(struct btrfs_fs_info *fs_info, struct btrfs_qgroup *qgroup)

fs/btrfs/qgroup.c

1741

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

1742

squota_check_parent_usage(fs_info, qgroup);

fs/btrfs/qgroup.c

1751

static bool can_delete_squota_subvol_qgroup(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

1754

ASSERT(btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE);

fs/btrfs/qgroup.c

1765

static int can_delete_qgroup(struct btrfs_fs_info *fs_info, struct btrfs_qgroup *qgroup)

fs/btrfs/qgroup.c

177

static struct btrfs_qgroup *find_qgroup_rb(const struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

1773

return can_delete_parent_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

1792

ret = btrfs_find_root(fs_info->tree_root, &key, path, NULL, NULL);

fs/btrfs/qgroup.c

1801

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

1802

return can_delete_squota_subvol_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

1808

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

1813

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1814

if (!fs_info->quota_root) {

fs/btrfs/qgroup.c

1819

qgroup = find_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

182

node = rb_find(&qgroupid, &fs_info->qgroup_tree, btrfs_qgroup_qgroupid_key_cmp);

fs/btrfs/qgroup.c

1825

ret = can_delete_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

1852

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1863

btrfs_warn_rl(fs_info,

fs/btrfs/qgroup.c

1877

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_FULL &&

fs/btrfs/qgroup.c

1878

!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT)) {

fs/btrfs/qgroup.c

1882

qgroup_mark_inconsistent(fs_info,

fs/btrfs/qgroup.c

1889

del_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

1890

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1897

btrfs_sysfs_del_one_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

1900

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1904

int btrfs_qgroup_cleanup_dropped_subvolume(struct btrfs_fs_info *fs_info, u64 subvolid)

fs/btrfs/qgroup.c

1909

if (!btrfs_is_fstree(subvolid) || !btrfs_qgroup_enabled(fs_info) ||

fs/btrfs/qgroup.c

1910

!fs_info->quota_root)

fs/btrfs/qgroup.c

1917

ret = btrfs_commit_current_transaction(fs_info->quota_root);

fs/btrfs/qgroup.c

1922

trans = btrfs_start_transaction(fs_info->quota_root, 2);

fs/btrfs/qgroup.c

1942

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

1951

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1952

if (!fs_info->quota_root) {

fs/btrfs/qgroup.c

1957

qgroup = find_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

1963

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

2002

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

2006

qgroup_mark_inconsistent(fs_info, "qgroup item update error %d", ret);

fs/btrfs/qgroup.c

2009

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

201

static struct btrfs_qgroup *add_qgroup_rb(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

2024

int btrfs_qgroup_trace_extent_nolock(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

2030

const unsigned long index = (bytenr >> fs_info->sectorsize_bits);

fs/btrfs/qgroup.c

2032

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

2037

btrfs_err_rl(fs_info,

fs/btrfs/qgroup.c

2040

btrfs_err_32bit_limit(fs_info);

fs/btrfs/qgroup.c

2045

trace_btrfs_qgroup_trace_extent(fs_info, record, bytenr);

fs/btrfs/qgroup.c

2061

qgroup_mark_inconsistent(fs_info, "xarray insert error: %d", xa_err(ret));

fs/btrfs/qgroup.c

2093

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2096

.fs_info = fs_info,

fs/btrfs/qgroup.c

2100

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

211

node = rb_find_add(&prealloc->node, &fs_info->qgroup_tree, btrfs_qgroup_qgroupid_cmp);

fs/btrfs/qgroup.c

2123

if (fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_NO_ACCOUNTING)

fs/btrfs/qgroup.c

2128

qgroup_mark_inconsistent(fs_info,

fs/btrfs/qgroup.c

2160

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2163

const unsigned long index = (bytenr >> fs_info->sectorsize_bits);

fs/btrfs/qgroup.c

2166

if (!btrfs_qgroup_full_accounting(fs_info) || bytenr == 0 || num_bytes == 0)

fs/btrfs/qgroup.c

2179

ret = btrfs_qgroup_trace_extent_nolock(fs_info, delayed_refs, record, bytenr);

fs/btrfs/qgroup.c

2198

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2206

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

2351

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2352

u32 nodesize = fs_info->nodesize;

fs/btrfs/qgroup.c

2468

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2478

btrfs_err_rl(fs_info,

fs/btrfs/qgroup.c

249

static int del_qgroup_rb(struct btrfs_fs_info *fs_info, u64 qgroupid)

fs/btrfs/qgroup.c

2494

btrfs_err_rl(fs_info,

fs/btrfs/qgroup.c

251

struct btrfs_qgroup *qgroup = find_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

256

rb_erase(&qgroup->node, &fs_info->qgroup_tree);

fs/btrfs/qgroup.c

2568

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2573

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

2578

btrfs_err_rl(fs_info,

fs/btrfs/qgroup.c

2612

qgroup_mark_inconsistent(fs_info, "%s error: %d", __func__, ret);

fs/btrfs/qgroup.c

2630

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2640

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

2643

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

2644

drop_subptree_thres = fs_info->qgroup_drop_subtree_thres;

fs/btrfs/qgroup.c

2645

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

2656

qgroup_mark_inconsistent(fs_info, "subtree level reached threshold");

fs/btrfs/qgroup.c

2717

fs_info->nodesize);

fs/btrfs/qgroup.c

2764

static void qgroup_update_refcnt(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

2778

qg = find_qgroup_rb(fs_info, unode->val);

fs/btrfs/qgroup.c

2837

static void qgroup_update_counters(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

2850

trace_btrfs_qgroup_update_counters(fs_info, qg, cur_old_count,

fs/btrfs/qgroup.c

2915

qgroup_dirty(fs_info, qg);

fs/btrfs/qgroup.c

2952

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2963

if (!btrfs_qgroup_full_accounting(fs_info) ||

fs/btrfs/qgroup.c

2964

fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_NO_ACCOUNTING)

fs/btrfs/qgroup.c

297

static int add_relation_rb(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

2982

trace_btrfs_qgroup_account_extent(fs_info, trans->transid, bytenr,

fs/btrfs/qgroup.c

2985

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

2986

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {

fs/btrfs/qgroup.c

2987

if (fs_info->qgroup_rescan_progress.objectid <= bytenr) {

fs/btrfs/qgroup.c

2988

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

2993

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

2995

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

2996

seq = fs_info->qgroup_seq;

fs/btrfs/qgroup.c

2999

qgroup_update_refcnt(fs_info, old_roots, &qgroups, seq, true);

fs/btrfs/qgroup.c

3002

qgroup_update_refcnt(fs_info, new_roots, &qgroups, seq, false);

fs/btrfs/qgroup.c

3004

qgroup_update_counters(fs_info, &qgroups, nr_old_roots, nr_new_roots,

fs/btrfs/qgroup.c

3017

fs_info->qgroup_seq += max(nr_old_roots, nr_new_roots) + 1;

fs/btrfs/qgroup.c

3018

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3027

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

3036

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

304

member = find_qgroup_rb(fs_info, memberid);

fs/btrfs/qgroup.c

3042

const u64 bytenr = (((u64)index) << fs_info->sectorsize_bits);

fs/btrfs/qgroup.c

3045

trace_btrfs_qgroup_account_extents(fs_info, record, bytenr);

fs/btrfs/qgroup.c

3047

if (!ret && !(fs_info->qgroup_flags &

fs/btrfs/qgroup.c

305

parent = find_qgroup_rb(fs_info, parentid);

fs/btrfs/qgroup.c

3052

ctx.fs_info = fs_info;

fs/btrfs/qgroup.c

3101

btrfs_qgroup_free_refroot(fs_info,

fs/btrfs/qgroup.c

311

static int del_relation_rb(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

3113

trace_btrfs_qgroup_num_dirty_extents(fs_info, trans->transid, num_dirty_extents);

fs/btrfs/qgroup.c

3123

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

3132

lockdep_assert_held(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

3134

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

3137

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3138

while (!list_empty(&fs_info->dirty_qgroups)) {

fs/btrfs/qgroup.c

3140

qgroup = list_first_entry(&fs_info->dirty_qgroups,

fs/btrfs/qgroup.c

3143

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3146

qgroup_mark_inconsistent(fs_info,

fs/btrfs/qgroup.c

3150

qgroup_mark_inconsistent(fs_info,

fs/btrfs/qgroup.c

3152

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3154

if (btrfs_qgroup_enabled(fs_info))

fs/btrfs/qgroup.c

3155

fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_ON;

fs/btrfs/qgroup.c

3157

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_ON;

fs/btrfs/qgroup.c

3158

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3162

qgroup_mark_inconsistent(fs_info,

fs/btrfs/qgroup.c

3168

int btrfs_qgroup_check_inherit(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

318

member = find_qgroup_rb(fs_info, memberid);

fs/btrfs/qgroup.c

319

parent = find_qgroup_rb(fs_info, parentid);

fs/btrfs/qgroup.c

3197

if (!btrfs_qgroup_enabled(fs_info))

fs/btrfs/qgroup.c

3213

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3214

qgroup = find_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

3216

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3219

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3224

static int qgroup_auto_inherit(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

3239

inode_qg = find_qgroup_rb(fs_info, inode_rootid);

fs/btrfs/qgroup.c

3274

static int qgroup_snapshot_quick_inherit(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

3282

const u32 nodesize = fs_info->nodesize;

fs/btrfs/qgroup.c

3285

if (btrfs_qgroup_mode(fs_info) != BTRFS_QGROUP_MODE_FULL)

fs/btrfs/qgroup.c

3288

src = find_qgroup_rb(fs_info, srcid);

fs/btrfs/qgroup.c

3291

parent = find_qgroup_rb(fs_info, parentid);

fs/btrfs/qgroup.c

33

enum btrfs_qgroup_mode btrfs_qgroup_mode(const struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

3328

qgroup_dirty(fs_info, qgroup);

fs/btrfs/qgroup.c

335

int btrfs_verify_qgroup_counts(const struct btrfs_fs_info *fs_info, u64 qgroupid,

fs/btrfs/qgroup.c

3351

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

3362

if (!btrfs_qgroup_enabled(fs_info))

fs/btrfs/qgroup.c

3381

spin_lock(&fs_info->trans_lock);

fs/btrfs/qgroup.c

3384

spin_unlock(&fs_info->trans_lock);

fs/btrfs/qgroup.c

3387

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

3389

quota_root = fs_info->quota_root;

fs/btrfs/qgroup.c

3395

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE && !inherit) {

fs/btrfs/qgroup.c

3396

ret = qgroup_auto_inherit(fs_info, inode_rootid, &inherit);

fs/btrfs/qgroup.c

340

qgroup = find_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

3407

srcgroup = find_qgroup_rb(fs_info, *i_qgroups);

fs/btrfs/qgroup.c

3463

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3465

dstgroup = add_qgroup_rb(fs_info, prealloc, objectid);

fs/btrfs/qgroup.c

3475

qgroup_dirty(fs_info, dstgroup);

fs/btrfs/qgroup.c

3478

if (srcid && btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_FULL) {

fs/btrfs/qgroup.c

3479

srcgroup = find_qgroup_rb(fs_info, srcid);

fs/btrfs/qgroup.c

3488

level_size = fs_info->nodesize;

fs/btrfs/qgroup.c

349

static bool squota_check_parent_usage(struct btrfs_fs_info *fs_info, struct btrfs_qgroup *parent)

fs/btrfs/qgroup.c

35

if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags))

fs/btrfs/qgroup.c

3503

qgroup_dirty(fs_info, dstgroup);

fs/btrfs/qgroup.c

3504

qgroup_dirty(fs_info, srcgroup);

fs/btrfs/qgroup.c

3520

ret = add_relation_rb(fs_info, qlist_prealloc[i], objectid,

fs/btrfs/qgroup.c

3528

ret = qgroup_snapshot_quick_inherit(fs_info, srcid, *i_qgroups);

fs/btrfs/qgroup.c

3545

src = find_qgroup_rb(fs_info, i_qgroups[0]);

fs/btrfs/qgroup.c

3546

dst = find_qgroup_rb(fs_info, i_qgroups[1]);

fs/btrfs/qgroup.c

3566

src = find_qgroup_rb(fs_info, i_qgroups[0]);

fs/btrfs/qgroup.c

3567

dst = find_qgroup_rb(fs_info, i_qgroups[1]);

fs/btrfs/qgroup.c

3580

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3582

ret = btrfs_sysfs_add_one_qgroup(fs_info, dstgroup);

fs/btrfs/qgroup.c

3585

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

3587

qgroup_mark_inconsistent(fs_info, "qgroup inherit needs a rescan");

fs/btrfs/qgroup.c

359

if (btrfs_qgroup_mode(fs_info) != BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

3616

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/qgroup.c

3627

if (test_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags) &&

fs/btrfs/qgroup.c

3631

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3632

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

3635

qgroup = find_qgroup_rb(fs_info, ref_root);

fs/btrfs/qgroup.c

3657

qgroup_rsv_add(fs_info, qgroup, num_bytes, type);

fs/btrfs/qgroup.c

3661

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3674

void btrfs_qgroup_free_refroot(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

3691

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3693

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

3696

qgroup = find_qgroup_rb(fs_info, ref_root);

fs/btrfs/qgroup.c

37

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE)

fs/btrfs/qgroup.c

3711

qgroup_rsv_release(fs_info, qgroup, num_bytes, type);

fs/btrfs/qgroup.c

3718

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3743

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

3752

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

3755

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3756

extent_root = btrfs_extent_root(fs_info,

fs/btrfs/qgroup.c

3757

fs_info->qgroup_rescan_progress.objectid);

fs/btrfs/qgroup.c

3759

btrfs_err(fs_info,

fs/btrfs/qgroup.c

3761

fs_info->qgroup_rescan_progress.objectid);

fs/btrfs/qgroup.c

3762

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3767

&fs_info->qgroup_rescan_progress,

fs/btrfs/qgroup.c

3770

btrfs_debug(fs_info,

fs/btrfs/qgroup.c

3772

BTRFS_KEY_FMT_VALUE(&fs_info->qgroup_rescan_progress), ret);

fs/btrfs/qgroup.c

3783

fs_info->qgroup_rescan_progress.objectid = (u64)-1;

fs/btrfs/qgroup.c

3785

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3792

fs_info->qgroup_rescan_progress.objectid = found.objectid + 1;

fs/btrfs/qgroup.c

3797

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3802

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3812

num_bytes = fs_info->nodesize;

fs/btrfs/qgroup.c

3817

ctx.fs_info = fs_info;

fs/btrfs/qgroup.c

3834

fs_info->qgroup_rescan_progress.objectid = (u64)-1;

fs/btrfs/qgroup.c

3839

static bool rescan_should_stop(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

3841

if (btrfs_fs_closing(fs_info))

fs/btrfs/qgroup.c

3843

if (test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state))

fs/btrfs/qgroup.c

3845

if (!btrfs_qgroup_enabled(fs_info))

fs/btrfs/qgroup.c

3847

if (fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN)

fs/btrfs/qgroup.c

385

static void qgroup_mark_inconsistent(struct btrfs_fs_info *fs_info, const char *fmt, ...)

fs/btrfs/qgroup.c

3854

struct btrfs_fs_info *fs_info = container_of(work, struct btrfs_fs_info,

fs/btrfs/qgroup.c

3862

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

387

const u64 old_flags = fs_info->qgroup_flags;

fs/btrfs/qgroup.c

3877

while (!ret && !(stopped = rescan_should_stop(fs_info))) {

fs/btrfs/qgroup.c

3878

trans = btrfs_start_transaction(fs_info->fs_root, 0);

fs/btrfs/qgroup.c

389

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

3896

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3898

fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT) {

fs/btrfs/qgroup.c

3899

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;

fs/btrfs/qgroup.c

3901

fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;

fs/btrfs/qgroup.c

3903

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

391

fs_info->qgroup_flags |= (BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT |

fs/btrfs/qgroup.c

3913

trans = btrfs_start_transaction(fs_info->quota_root, 1);

fs/btrfs/qgroup.c

3917

btrfs_err(fs_info,

fs/btrfs/qgroup.c

3925

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3927

fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN)

fs/btrfs/qgroup.c

3928

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;

fs/btrfs/qgroup.c

3934

btrfs_err(fs_info, "fail to update qgroup status: %d", ret);

fs/btrfs/qgroup.c

3937

fs_info->qgroup_rescan_running = false;

fs/btrfs/qgroup.c

3938

fs_info->qgroup_flags &= ~BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN;

fs/btrfs/qgroup.c

3939

complete_all(&fs_info->qgroup_rescan_completion);

fs/btrfs/qgroup.c

3940

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3948

btrfs_info(fs_info, "qgroup scan paused");

fs/btrfs/qgroup.c

3949

} else if (fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN) {

fs/btrfs/qgroup.c

3950

btrfs_info(fs_info, "qgroup scan cancelled");

fs/btrfs/qgroup.c

3952

btrfs_info(fs_info, "qgroup scan completed%s",

fs/btrfs/qgroup.c

3955

btrfs_err(fs_info, "qgroup scan failed with %d", ret);

fs/btrfs/qgroup.c

3964

qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid,

fs/btrfs/qgroup.c

3969

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE) {

fs/btrfs/qgroup.c

3970

btrfs_warn(fs_info, "qgroup rescan init failed, running in simple mode");

fs/btrfs/qgroup.c

3976

if (!(fs_info->qgroup_flags &

fs/btrfs/qgroup.c

3978

btrfs_debug(fs_info,

fs/btrfs/qgroup.c

3981

} else if (!(fs_info->qgroup_flags &

fs/btrfs/qgroup.c

3983

btrfs_debug(fs_info,

fs/btrfs/qgroup.c

3992

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3995

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {

fs/btrfs/qgroup.c

3997

} else if (!(fs_info->qgroup_flags &

fs/btrfs/qgroup.c

3999

btrfs_debug(fs_info,

fs/btrfs/qgroup.c

4002

} else if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED) {

fs/btrfs/qgroup.c

4008

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4011

fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_RESCAN;

fs/btrfs/qgroup.c

4014

memset(&fs_info->qgroup_rescan_progress, 0,

fs/btrfs/qgroup.c

4015

sizeof(fs_info->qgroup_rescan_progress));

fs/btrfs/qgroup.c

4016

fs_info->qgroup_flags &= ~(BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN |

fs/btrfs/qgroup.c

4018

fs_info->qgroup_rescan_progress.objectid = progress_objectid;

fs/btrfs/qgroup.c

4019

init_completion(&fs_info->qgroup_rescan_completion);

fs/btrfs/qgroup.c

402

btrfs_warn_rl(fs_info, "qgroup marked inconsistent, %pV", &vaf);

fs/btrfs/qgroup.c

4020

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4022

btrfs_init_work(&fs_info->qgroup_rescan_work,

fs/btrfs/qgroup.c

4028

qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

4033

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

4035

for (n = rb_first(&fs_info->qgroup_tree); n; n = rb_next(n)) {

fs/btrfs/qgroup.c

4041

qgroup_dirty(fs_info, qgroup);

fs/btrfs/qgroup.c

4043

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

4047

btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

4051

ret = qgroup_rescan_init(fs_info, 0, 1);

fs/btrfs/qgroup.c

4066

ret = btrfs_commit_current_transaction(fs_info->fs_root);

fs/btrfs/qgroup.c

4068

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;

fs/btrfs/qgroup.c

407

static void qgroup_read_enable_gen(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

4072

qgroup_rescan_zero_tracking(fs_info);

fs/btrfs/qgroup.c

4074

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4080

if (btrfs_qgroup_full_accounting(fs_info)) {

fs/btrfs/qgroup.c

4081

fs_info->qgroup_rescan_running = true;

fs/btrfs/qgroup.c

4082

btrfs_queue_work(fs_info->qgroup_rescan_workers,

fs/btrfs/qgroup.c

4083

&fs_info->qgroup_rescan_work);

fs/btrfs/qgroup.c

4087

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4092

int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

4098

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4099

running = fs_info->qgroup_rescan_running;

fs/btrfs/qgroup.c

4100

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4107

&fs_info->qgroup_rescan_completion);

fs/btrfs/qgroup.c

4109

wait_for_completion(&fs_info->qgroup_rescan_completion);

fs/btrfs/qgroup.c

411

ASSERT(btrfs_fs_incompat(fs_info, SIMPLE_QUOTA));

fs/btrfs/qgroup.c

4119

btrfs_qgroup_rescan_resume(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

4121

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {

fs/btrfs/qgroup.c

4122

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4123

fs_info->qgroup_rescan_running = true;

fs/btrfs/qgroup.c

4124

btrfs_queue_work(fs_info->qgroup_rescan_workers,

fs/btrfs/qgroup.c

4125

&fs_info->qgroup_rescan_work);

fs/btrfs/qgroup.c

4126

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

413

fs_info->qgroup_enable_gen = btrfs_qgroup_status_enable_gen(leaf, ptr);

fs/btrfs/qgroup.c

42

bool btrfs_qgroup_enabled(const struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

420

int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

424

struct btrfs_root *quota_root = fs_info->quota_root;

fs/btrfs/qgroup.c

4242

btrfs_run_delayed_iputs(root->fs_info);

fs/btrfs/qgroup.c

4243

btrfs_wait_on_delayed_iputs(root->fs_info);

fs/btrfs/qgroup.c

4263

if (btrfs_qgroup_mode(root->fs_info) == BTRFS_QGROUP_MODE_DISABLED ||

fs/btrfs/qgroup.c

432

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

4346

len = round_up(start + len, root->fs_info->sectorsize);

fs/btrfs/qgroup.c

4347

start = round_down(start, root->fs_info->sectorsize);

fs/btrfs/qgroup.c

4382

btrfs_qgroup_free_refroot(root->fs_info, btrfs_root_id(root), freed,

fs/btrfs/qgroup.c

44

return btrfs_qgroup_mode(fs_info) != BTRFS_QGROUP_MODE_DISABLED;

fs/btrfs/qgroup.c

4400

if (btrfs_qgroup_mode(inode->root->fs_info) == BTRFS_QGROUP_MODE_DISABLED) {

fs/btrfs/qgroup.c

441

ret = btrfs_sysfs_add_qgroups(fs_info);

fs/btrfs/qgroup.c

4421

btrfs_qgroup_free_refroot(inode->root->fs_info,

fs/btrfs/qgroup.c

445

fs_info->qgroup_flags = 0;

fs/btrfs/qgroup.c

4513

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/qgroup.c

4516

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED ||

fs/btrfs/qgroup.c

4520

BUG_ON(num_bytes != round_down(num_bytes, fs_info->nodesize));

fs/btrfs/qgroup.c

4560

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/qgroup.c

4562

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED ||

fs/btrfs/qgroup.c

4569

btrfs_qgroup_free_refroot(fs_info, btrfs_root_id(root), (u64)-1,

fs/btrfs/qgroup.c

4575

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/qgroup.c

4577

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED ||

fs/btrfs/qgroup.c

4588

BUG_ON(num_bytes != round_down(num_bytes, fs_info->nodesize));

fs/btrfs/qgroup.c

4591

btrfs_qgroup_free_refroot(fs_info, btrfs_root_id(root), num_bytes,

fs/btrfs/qgroup.c

4595

static void qgroup_convert_meta(struct btrfs_fs_info *fs_info, u64 ref_root,

fs/btrfs/qgroup.c

4603

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

4606

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

4607

qgroup = find_qgroup_rb(fs_info, ref_root);

fs/btrfs/qgroup.c

4615

qgroup_rsv_release(fs_info, qgroup, num_bytes,

fs/btrfs/qgroup.c

4617

if (!sb_rdonly(fs_info->sb))

fs/btrfs/qgroup.c

4618

qgroup_rsv_add(fs_info, qgroup, num_bytes,

fs/btrfs/qgroup.c

4626

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

4637

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/qgroup.c

4639

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED ||

fs/btrfs/qgroup.c

4646

qgroup_convert_meta(fs_info, btrfs_root_id(root), num_bytes);

fs/btrfs/qgroup.c

4647

if (!sb_rdonly(fs_info->sb))

fs/btrfs/qgroup.c

4671

btrfs_warn(inode->root->fs_info,

fs/btrfs/qgroup.c

4675

btrfs_qgroup_free_refroot(inode->root->fs_info,

fs/btrfs/qgroup.c

47

bool btrfs_qgroup_full_accounting(const struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

472

btrfs_err(fs_info,

fs/btrfs/qgroup.c

476

fs_info->qgroup_flags = btrfs_qgroup_status_flags(l, ptr);

fs/btrfs/qgroup.c

4763

struct btrfs_fs_info *fs_info = subvol_root->fs_info;

fs/btrfs/qgroup.c

477

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE)

fs/btrfs/qgroup.c

4770

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

4775

btrfs_err_rl(fs_info,

fs/btrfs/qgroup.c

478

qgroup_read_enable_gen(fs_info, l, slot, ptr);

fs/btrfs/qgroup.c

479

else if (btrfs_qgroup_status_generation(l, ptr) != fs_info->generation)

fs/btrfs/qgroup.c

480

qgroup_mark_inconsistent(fs_info, "qgroup generation mismatch");

fs/btrfs/qgroup.c

4840

qgroup_mark_inconsistent(fs_info, "%s error: %d", __func__, ret);

fs/btrfs/qgroup.c

4854

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/qgroup.c

4865

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

489

qgroup = find_qgroup_rb(fs_info, found_key.offset);

fs/btrfs/qgroup.c

49

return btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_FULL;

fs/btrfs/qgroup.c

4900

reloc_eb = read_tree_block(fs_info, block->reloc_bytenr, &check);

fs/btrfs/qgroup.c

4913

qgroup_mark_inconsistent(fs_info,

fs/btrfs/qgroup.c

492

qgroup_mark_inconsistent(fs_info, "inconsistent qgroup config");

fs/btrfs/qgroup.c

4932

int btrfs_record_squota_delta(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

4943

if (btrfs_qgroup_mode(fs_info) != BTRFS_QGROUP_MODE_SIMPLE &&

fs/btrfs/qgroup.c

4944

!test_bit(BTRFS_FS_SQUOTA_ENABLING, &fs_info->flags))

fs/btrfs/qgroup.c

495

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/qgroup.c

4951

if (delta->generation < fs_info->qgroup_enable_gen)

fs/btrfs/qgroup.c

4954

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

4955

qgroup = find_qgroup_rb(fs_info, root);

fs/btrfs/qgroup.c

4957

btrfs_warn(fs_info, "squota failed to find qgroup for root %llu", root);

fs/btrfs/qgroup.c

4969

btrfs_warn(fs_info,

fs/btrfs/qgroup.c

4979

qgroup_dirty(fs_info, qg);

fs/btrfs/qgroup.c

4987

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

502

qgroup = add_qgroup_rb(fs_info, prealloc, found_key.offset);

fs/btrfs/qgroup.c

523

ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

592

ret = add_relation_rb(fs_info, list, found_key.objectid,

fs/btrfs/qgroup.c

596

btrfs_warn(fs_info,

fs/btrfs/qgroup.c

612

fs_info->qgroup_flags |= flags;

fs/btrfs/qgroup.c

614

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON)

fs/btrfs/qgroup.c

615

set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);

fs/btrfs/qgroup.c

616

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN)

fs/btrfs/qgroup.c

617

ret = qgroup_rescan_init(fs_info, rescan_progress, 0);

fs/btrfs/qgroup.c

619

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;

fs/btrfs/qgroup.c

620

btrfs_sysfs_del_qgroups(fs_info);

fs/btrfs/qgroup.c

633

bool btrfs_check_quota_leak(const struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

638

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED)

fs/btrfs/qgroup.c

645

for (node = rb_first(&fs_info->qgroup_tree); node; node = rb_next(node)) {

fs/btrfs/qgroup.c

653

btrfs_warn(fs_info,

fs/btrfs/qgroup.c

667

void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

677

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

678

while ((n = rb_first(&fs_info->qgroup_tree))) {

fs/btrfs/qgroup.c

680

rb_erase(n, &fs_info->qgroup_tree);

fs/btrfs/qgroup.c

682

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

683

btrfs_sysfs_del_one_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

685

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

687

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

689

btrfs_sysfs_del_qgroups(fs_info);

fs/btrfs/qgroup.c

695

struct btrfs_root *quota_root = trans->fs_info->quota_root;

fs/btrfs/qgroup.c

714

struct btrfs_root *quota_root = trans->fs_info->quota_root;

fs/btrfs/qgroup.c

746

if (btrfs_is_testing(quota_root->fs_info))

fs/btrfs/qgroup.c

800

struct btrfs_root *quota_root = trans->fs_info->quota_root;

fs/btrfs/qgroup.c

82

static void qgroup_rsv_add(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

838

struct btrfs_root *quota_root = trans->fs_info->quota_root;

fs/btrfs/qgroup.c

86

trace_btrfs_qgroup_update_reserve(fs_info, qgroup, num_bytes, type);

fs/btrfs/qgroup.c

876

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

877

struct btrfs_root *quota_root = fs_info->quota_root;

fs/btrfs/qgroup.c

885

if (btrfs_is_testing(fs_info))

fs/btrfs/qgroup.c

90

static void qgroup_rsv_release(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

917

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

918

struct btrfs_root *quota_root = fs_info->quota_root;

fs/btrfs/qgroup.c

94

trace_btrfs_qgroup_update_reserve(fs_info, qgroup, -(s64)num_bytes, type);

fs/btrfs/qgroup.c

944

btrfs_set_qgroup_status_flags(l, ptr, fs_info->qgroup_flags &

fs/btrfs/qgroup.c

948

fs_info->qgroup_rescan_progress.objectid);

fs/btrfs/qgroup.c

997

int btrfs_quota_enable(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.h

331

enum btrfs_qgroup_mode btrfs_qgroup_mode(const struct btrfs_fs_info *fs_info);

fs/btrfs/qgroup.h

332

bool btrfs_qgroup_enabled(const struct btrfs_fs_info *fs_info);

fs/btrfs/qgroup.h

333

bool btrfs_qgroup_full_accounting(const struct btrfs_fs_info *fs_info);

fs/btrfs/qgroup.h

334

int btrfs_quota_enable(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.h

336

int btrfs_quota_disable(struct btrfs_fs_info *fs_info);

fs/btrfs/qgroup.h

337

int btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info);

fs/btrfs/qgroup.h

338

void btrfs_qgroup_rescan_resume(struct btrfs_fs_info *fs_info);

fs/btrfs/qgroup.h

339

int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.h

347

int btrfs_qgroup_cleanup_dropped_subvolume(struct btrfs_fs_info *fs_info, u64 subvolid);

fs/btrfs/qgroup.h

350

int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info);

fs/btrfs/qgroup.h

351

void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info);

fs/btrfs/qgroup.h

354

struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.h

373

int btrfs_qgroup_check_inherit(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.h

379

void btrfs_qgroup_free_refroot(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.h

384

int btrfs_verify_qgroup_counts(const struct btrfs_fs_info *fs_info, u64 qgroupid,

fs/btrfs/qgroup.h

417

bool btrfs_check_quota_leak(const struct btrfs_fs_info *fs_info);

fs/btrfs/qgroup.h

418

int btrfs_record_squota_delta(struct btrfs_fs_info *fs_info,

fs/btrfs/raid-stripe-tree.c

170

trace_btrfs_raid_extent_delete(fs_info, start, end,

fs/btrfs/raid-stripe-tree.c

21

struct btrfs_root *stripe_root = trans->fs_info->stripe_root;

fs/btrfs/raid-stripe-tree.c

311

ret = btrfs_search_slot(trans, trans->fs_info->stripe_root, key, path,

fs/btrfs/raid-stripe-tree.c

329

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/raid-stripe-tree.c

331

struct btrfs_root *stripe_root = fs_info->stripe_root;

fs/btrfs/raid-stripe-tree.c

344

trace_btrfs_insert_one_raid_extent(fs_info, bioc->logical, bioc->size,

fs/btrfs/raid-stripe-tree.c

379

if (!btrfs_fs_incompat(trans->fs_info, RAID_STRIPE_TREE))

fs/btrfs/raid-stripe-tree.c

398

int btrfs_get_raid_extent_offset(struct btrfs_fs_info *fs_info,

fs/btrfs/raid-stripe-tree.c

402

struct btrfs_root *stripe_root = fs_info->stripe_root;

fs/btrfs/raid-stripe-tree.c

418

btrfs_err_rl(fs_info, "missing raid stripe tree root for logical %llu",

fs/btrfs/raid-stripe-tree.c

492

trace_btrfs_get_raid_extent_offset(fs_info, logical, *length,

fs/btrfs/raid-stripe-tree.c

504

btrfs_debug(fs_info,

fs/btrfs/raid-stripe-tree.c

67

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/raid-stripe-tree.c

68

struct btrfs_root *stripe_root = fs_info->stripe_root;

fs/btrfs/raid-stripe-tree.c

78

if (!btrfs_fs_incompat(fs_info, RAID_STRIPE_TREE) || !stripe_root)

fs/btrfs/raid-stripe-tree.c

81

if (!btrfs_is_testing(fs_info)) {

fs/btrfs/raid-stripe-tree.c

85

map = btrfs_find_chunk_map(fs_info, start, length);

fs/btrfs/raid-stripe-tree.c

88

use_rst = btrfs_need_stripe_tree_update(fs_info, map->type);

fs/btrfs/raid-stripe-tree.h

26

int btrfs_get_raid_extent_offset(struct btrfs_fs_info *fs_info,

fs/btrfs/raid-stripe-tree.h

37

static inline bool btrfs_need_stripe_tree_update(struct btrfs_fs_info *fs_info,

fs/btrfs/raid-stripe-tree.h

43

if (!btrfs_fs_incompat(fs_info, RAID_STRIPE_TREE))

fs/btrfs/raid56.c

102

(rbio)->bioc->fs_info : NULL; \

fs/btrfs/raid56.c

1041

static struct btrfs_raid_bio *alloc_rbio(struct btrfs_fs_info *fs_info,

fs/btrfs/raid56.c

1048

BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits;

fs/btrfs/raid56.c

1050

const unsigned int step = min(fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/raid56.c

1051

const unsigned int sector_nsteps = fs_info->sectorsize / step;

fs/btrfs/raid56.c

1058

ASSERT(IS_ALIGNED(PAGE_SIZE, fs_info->sectorsize) ||

fs/btrfs/raid56.c

1059

IS_ALIGNED(fs_info->sectorsize, PAGE_SIZE));

fs/btrfs/raid56.c

114

(rbio)->bioc->fs_info : NULL; \

fs/btrfs/raid56.c

1221

const u32 sectorsize = rbio->bioc->fs_info->sectorsize;

fs/btrfs/raid56.c

1290

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

1291

const u32 step = min(fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/raid56.c

1292

const u32 step_bits = min(fs_info->sectorsize_bits, PAGE_SHIFT);

fs/btrfs/raid56.c

1392

const u32 step = min(rbio->bioc->fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/raid56.c

1547

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

1550

int total_nr_sector = offset >> fs_info->sectorsize_bits;

fs/btrfs/raid56.c

1555

bio->bi_iter.bi_size >> fs_info->sectorsize_bits);

fs/btrfs/raid56.c

1599

const u32 sectorsize = rbio->bioc->fs_info->sectorsize;

fs/btrfs/raid56.c

1646

(bio_size >> rbio->bioc->fs_info->sectorsize_bits); i++)

fs/btrfs/raid56.c

1654

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

1655

const u32 step = min(fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/raid56.c

1678

if (!IS_ALIGNED(offset, fs_info->sectorsize))

fs/btrfs/raid56.c

1687

expected_csum = rbio->csum_buf + total_sector_nr * fs_info->csum_size;

fs/btrfs/raid56.c

1688

btrfs_calculate_block_csum_pages(fs_info, paddrs, csum_buf);

fs/btrfs/raid56.c

1689

if (unlikely(memcmp(csum_buf, expected_csum, fs_info->csum_size) != 0))

fs/btrfs/raid56.c

1814

const struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

1818

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/raid56.c

1833

fs_info->sectorsize_bits) % rbio->stripe_nsectors;

fs/btrfs/raid56.c

1844

struct btrfs_fs_info *fs_info = bioc->fs_info;

fs/btrfs/raid56.c

1849

rbio = alloc_rbio(fs_info, bioc);

fs/btrfs/raid56.c

186

queue_work(rbio->bioc->fs_info->rmw_workers, &rbio->work);

fs/btrfs/raid56.c

1863

cb = blk_check_plugged(raid_unplug, fs_info, sizeof(*plug));

fs/btrfs/raid56.c

1867

plug->info = fs_info;

fs/btrfs/raid56.c

1885

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

1908

fs_info->csum_size;

fs/btrfs/raid56.c

1909

btrfs_calculate_block_csum_pages(fs_info, paddrs, csum_buf);

fs/btrfs/raid56.c

1910

if (unlikely(memcmp(csum_buf, csum_expected, fs_info->csum_size) != 0))

fs/btrfs/raid56.c

1921

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

1922

const u32 step = min(fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/raid56.c

2249

struct btrfs_fs_info *fs_info = bioc->fs_info;

fs/btrfs/raid56.c

2252

rbio = alloc_rbio(fs_info, bioc);

fs/btrfs/raid56.c

2277

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

2281

fs_info->sectorsize_bits;

fs/btrfs/raid56.c

2303

fs_info->csum_size, GFP_NOFS);

fs/btrfs/raid56.c

2311

csum_root = btrfs_csum_root(fs_info, rbio->bioc->full_stripe_logical);

fs/btrfs/raid56.c

2313

btrfs_err(fs_info,

fs/btrfs/raid56.c

2324

if (bitmap_empty(rbio->csum_bitmap, len >> fs_info->sectorsize_bits))

fs/btrfs/raid56.c

233

const u32 step = min(rbio->bioc->fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/raid56.c

2334

btrfs_warn_rl(fs_info,

fs/btrfs/raid56.c

2552

struct btrfs_fs_info *fs_info = bioc->fs_info;

fs/btrfs/raid56.c

2556

rbio = alloc_rbio(fs_info, bioc);

fs/btrfs/raid56.c

2587

const u32 step = min(PAGE_SIZE, rbio->bioc->fs_info->sectorsize);

fs/btrfs/raid56.c

2634

const u32 step = min(rbio->bioc->fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/raid56.c

3002

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

3043

offset_in_full_stripe >> fs_info->sectorsize_bits,

fs/btrfs/raid56.c

3044

BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits);

fs/btrfs/raid56.c

311

sector_nr = (page_nr << PAGE_SHIFT) >> rbio->bioc->fs_info->sectorsize_bits;

fs/btrfs/raid56.c

324

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

329

nr_sectors = round_up(PAGE_SIZE, fs_info->sectorsize) >> fs_info->sectorsize_bits;

fs/btrfs/raid56.c

358

const u32 step = min(rbio->bioc->fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/raid56.c

43

static void dump_bioc(const struct btrfs_fs_info *fs_info, const struct btrfs_io_context *bioc)

fs/btrfs/raid56.c

46

btrfs_crit(fs_info, "bioc=NULL");

fs/btrfs/raid56.c

477

table = rbio->bioc->fs_info->stripe_hash_table;

fs/btrfs/raid56.c

49

btrfs_crit(fs_info,

fs/btrfs/raid56.c

531

table = rbio->bioc->fs_info->stripe_hash_table;

fs/btrfs/raid56.c

55

btrfs_crit(fs_info, " nr=%d devid=%llu physical=%llu",

fs/btrfs/raid56.c

588

table = rbio->bioc->fs_info->stripe_hash_table;

fs/btrfs/raid56.c

61

static void btrfs_dump_rbio(const struct btrfs_fs_info *fs_info,

fs/btrfs/raid56.c

67

dump_bioc(fs_info, rbio->bioc);

fs/btrfs/raid56.c

68

btrfs_crit(fs_info,

fs/btrfs/raid56.c

778

h = rbio->bioc->fs_info->stripe_hash_table->table + rbio_bucket(rbio);

fs/btrfs/raid56.c

79

(rbio)->bioc->fs_info : NULL; \

fs/btrfs/raid56.c

861

h = rbio->bioc->fs_info->stripe_hash_table->table + bucket;

fs/btrfs/raid56.c

90

(rbio)->bioc->fs_info : NULL; \

fs/btrfs/ref-verify.c

1021

btrfs_free_ref_cache(fs_info);

fs/btrfs/ref-verify.c

1022

btrfs_clear_opt(fs_info->mount_opt, REF_VERIFY);

fs/btrfs/ref-verify.c

196

static void __print_stack_trace(struct btrfs_fs_info *fs_info,

fs/btrfs/ref-verify.c

200

btrfs_err(fs_info, " ref-verify: no stacktrace");

fs/btrfs/ref-verify.c

210

static inline void __print_stack_trace(struct btrfs_fs_info *fs_info,

fs/btrfs/ref-verify.c

213

btrfs_err(fs_info, " ref-verify: no stacktrace support");

fs/btrfs/ref-verify.c

245

static struct block_entry *add_block_entry(struct btrfs_fs_info *fs_info,

fs/btrfs/ref-verify.c

265

spin_lock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

266

exist = insert_block_entry(&fs_info->block_tree, be);

fs/btrfs/ref-verify.c

294

static int add_tree_block(struct btrfs_fs_info *fs_info, u64 ref_root,

fs/btrfs/ref-verify.c

314

be = add_block_entry(fs_info, bytenr, fs_info->nodesize, ref_root);

fs/btrfs/ref-verify.c

334

spin_unlock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

339

static int add_shared_data_ref(struct btrfs_fs_info *fs_info,

fs/btrfs/ref-verify.c

349

be = add_block_entry(fs_info, bytenr, num_bytes, 0);

fs/btrfs/ref-verify.c

359

spin_unlock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

360

btrfs_err(fs_info, "existing shared ref when reading from disk?");

fs/btrfs/ref-verify.c

364

spin_unlock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

368

static int add_extent_data_ref(struct btrfs_fs_info *fs_info,

fs/btrfs/ref-verify.c

384

be = add_block_entry(fs_info, bytenr, num_bytes, ref_root);

fs/btrfs/ref-verify.c

397

spin_unlock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

398

btrfs_err(fs_info, "existing ref when reading from disk?");

fs/btrfs/ref-verify.c

405

spin_unlock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

406

btrfs_err(fs_info, "missing root in new block entry?");

fs/btrfs/ref-verify.c

410

spin_unlock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

414

static int process_extent_item(struct btrfs_fs_info *fs_info,

fs/btrfs/ref-verify.c

453

ret = add_tree_block(fs_info, offset, 0, key->objectid,

fs/btrfs/ref-verify.c

457

ret = add_tree_block(fs_info, 0, offset, key->objectid,

fs/btrfs/ref-verify.c

462

ret = add_extent_data_ref(fs_info, leaf, dref,

fs/btrfs/ref-verify.c

468

ret = add_shared_data_ref(fs_info, offset, count,

fs/btrfs/ref-verify.c

472

if (!btrfs_fs_incompat(fs_info, SIMPLE_QUOTA)) {

fs/btrfs/ref-verify.c

473

btrfs_err(fs_info,

fs/btrfs/ref-verify.c

479

btrfs_err(fs_info, "invalid key type in iref");

fs/btrfs/ref-verify.c

494

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ref-verify.c

511

ret = process_extent_item(fs_info, path, &key, i,

fs/btrfs/ref-verify.c

515

ret = add_tree_block(fs_info, key.offset, 0,

fs/btrfs/ref-verify.c

519

ret = add_tree_block(fs_info, 0, key.offset,

fs/btrfs/ref-verify.c

525

ret = add_extent_data_ref(fs_info, leaf, dref, *bytenr,

fs/btrfs/ref-verify.c

532

ret = add_shared_data_ref(fs_info, key.offset, count,

fs/btrfs/ref-verify.c

599

static void dump_ref_action(struct btrfs_fs_info *fs_info,

fs/btrfs/ref-verify.c

602

btrfs_err(fs_info,

fs/btrfs/ref-verify.c

606

__print_stack_trace(fs_info, ra);

fs/btrfs/ref-verify.c

613

static void dump_block_entry(struct btrfs_fs_info *fs_info,

fs/btrfs/ref-verify.c

621

btrfs_err(fs_info,

fs/btrfs/ref-verify.c

628

btrfs_err(fs_info,

fs/btrfs/ref-verify.c

636

btrfs_err(fs_info, " root entry %llu, num_refs %llu",

fs/btrfs/ref-verify.c

641

dump_ref_action(fs_info, ra);

fs/btrfs/ref-verify.c

652

int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,

fs/btrfs/ref-verify.c

669

if (!btrfs_test_opt(fs_info, REF_VERIFY))

fs/btrfs/ref-verify.c

725

be = add_block_entry(fs_info, bytenr, num_bytes, ref_root);

fs/btrfs/ref-verify.c

737

btrfs_err(fs_info,

fs/btrfs/ref-verify.c

739

dump_block_entry(fs_info, be);

fs/btrfs/ref-verify.c

740

dump_ref_action(fs_info, ra);

fs/btrfs/ref-verify.c

775

spin_lock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

776

be = lookup_block_entry(&fs_info->block_tree, bytenr);

fs/btrfs/ref-verify.c

778

btrfs_err(fs_info,

fs/btrfs/ref-verify.c

781

dump_ref_action(fs_info, ra);

fs/btrfs/ref-verify.c

787

btrfs_err(fs_info,

fs/btrfs/ref-verify.c

790

dump_block_entry(fs_info, be);

fs/btrfs/ref-verify.c

791

dump_ref_action(fs_info, ra);

fs/btrfs/ref-verify.c

811

btrfs_err(fs_info,

fs/btrfs/ref-verify.c

813

dump_block_entry(fs_info, be);

fs/btrfs/ref-verify.c

814

dump_ref_action(fs_info, ra);

fs/btrfs/ref-verify.c

827

btrfs_err(fs_info,

fs/btrfs/ref-verify.c

829

dump_block_entry(fs_info, be);

fs/btrfs/ref-verify.c

830

dump_ref_action(fs_info, ra);

fs/btrfs/ref-verify.c

838

btrfs_err(fs_info,

fs/btrfs/ref-verify.c

840

dump_block_entry(fs_info, be);

fs/btrfs/ref-verify.c

841

dump_ref_action(fs_info, ra);

fs/btrfs/ref-verify.c

858

btrfs_err(fs_info, "failed to find root %llu for %llu",

fs/btrfs/ref-verify.c

860

dump_block_entry(fs_info, be);

fs/btrfs/ref-verify.c

861

dump_ref_action(fs_info, ra);

fs/btrfs/ref-verify.c

878

spin_unlock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

881

btrfs_free_ref_cache(fs_info);

fs/btrfs/ref-verify.c

882

btrfs_clear_opt(fs_info->mount_opt, REF_VERIFY);

fs/btrfs/ref-verify.c

888

void btrfs_free_ref_cache(struct btrfs_fs_info *fs_info)

fs/btrfs/ref-verify.c

893

if (!btrfs_test_opt(fs_info, REF_VERIFY))

fs/btrfs/ref-verify.c

896

spin_lock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

897

while ((n = rb_first(&fs_info->block_tree))) {

fs/btrfs/ref-verify.c

899

rb_erase(&be->node, &fs_info->block_tree);

fs/btrfs/ref-verify.c

901

cond_resched_lock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

903

spin_unlock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

906

void btrfs_free_ref_tree_range(struct btrfs_fs_info *fs_info, u64 start,

fs/btrfs/ref-verify.c

912

if (!btrfs_test_opt(fs_info, REF_VERIFY))

fs/btrfs/ref-verify.c

915

spin_lock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

916

n = fs_info->block_tree.rb_node;

fs/btrfs/ref-verify.c

939

spin_unlock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

948

btrfs_err(fs_info,

fs/btrfs/ref-verify.c

951

dump_block_entry(fs_info, be);

fs/btrfs/ref-verify.c

959

btrfs_err(fs_info,

fs/btrfs/ref-verify.c

962

dump_block_entry(fs_info, be);

fs/btrfs/ref-verify.c

964

rb_erase(&be->node, &fs_info->block_tree);

fs/btrfs/ref-verify.c

967

spin_unlock(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.c

971

int btrfs_build_ref_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/ref-verify.c

980

if (!btrfs_test_opt(fs_info, REF_VERIFY))

fs/btrfs/ref-verify.c

983

extent_root = btrfs_extent_root(fs_info, 0);

fs/btrfs/ref-verify.c

986

btrfs_warn(fs_info, "ref-verify: extent tree not available, disabling");

fs/btrfs/ref-verify.c

987

btrfs_clear_opt(fs_info->mount_opt, REF_VERIFY);

fs/btrfs/ref-verify.h

19

int btrfs_build_ref_tree(struct btrfs_fs_info *fs_info);

fs/btrfs/ref-verify.h

20

void btrfs_free_ref_cache(struct btrfs_fs_info *fs_info);

fs/btrfs/ref-verify.h

21

int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,

fs/btrfs/ref-verify.h

23

void btrfs_free_ref_tree_range(struct btrfs_fs_info *fs_info, u64 start,

fs/btrfs/ref-verify.h

26

static inline void btrfs_init_ref_verify(struct btrfs_fs_info *fs_info)

fs/btrfs/ref-verify.h

28

spin_lock_init(&fs_info->ref_verify_lock);

fs/btrfs/ref-verify.h

29

fs_info->block_tree = RB_ROOT;

fs/btrfs/ref-verify.h

32

static inline int btrfs_build_ref_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/ref-verify.h

37

static inline void btrfs_free_ref_cache(struct btrfs_fs_info *fs_info)

fs/btrfs/ref-verify.h

41

static inline int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,

fs/btrfs/ref-verify.h

47

static inline void btrfs_free_ref_tree_range(struct btrfs_fs_info *fs_info,

fs/btrfs/ref-verify.h

52

static inline void btrfs_init_ref_verify(struct btrfs_fs_info *fs_info)

fs/btrfs/reflink.c

142

btrfs_folio_set_uptodate(fs_info, folio, file_offset, block_size);

fs/btrfs/reflink.c

143

btrfs_folio_set_dirty(fs_info, folio, file_offset, block_size);

fs/btrfs/reflink.c

175

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/reflink.c

177

fs_info->sectorsize);

fs/btrfs/reflink.c

399

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/reflink.c

413

buf = kvmalloc(fs_info->nodesize, GFP_KERNEL);

fs/btrfs/reflink.c

577

ASSERT(datal <= fs_info->sectorsize);

fs/btrfs/reflink.c

580

WARN_ON(datal > fs_info->sectorsize)) {

fs/btrfs/reflink.c

613

fs_info->sectorsize);

fs/btrfs/reflink.c

62

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/reflink.c

63

const u32 block_size = fs_info->sectorsize;

fs/btrfs/reflink.c

693

struct btrfs_fs_info *fs_info = src->root->fs_info;

fs/btrfs/reflink.c

694

const u64 bs = fs_info->sectorsize;

fs/btrfs/reflink.c

708

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/reflink.c

722

btrfs_warn_rl(root_dst->fs_info,

fs/btrfs/reflink.c

762

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/reflink.c

765

u64 bs = fs_info->sectorsize;

fs/btrfs/reflink.c

833

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/reflink.c

844

u64 bs = inode_out->root->fs_info->sectorsize;

fs/btrfs/relocation.c

1090

struct btrfs_fs_info *fs_info = dest->fs_info;

fs/btrfs/relocation.c

1154

blocksize = fs_info->nodesize;

fs/btrfs/relocation.c

1411

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

1449

WARN_ON(!IS_ALIGNED(start, fs_info->sectorsize));

fs/btrfs/relocation.c

1464

WARN_ON(!IS_ALIGNED(end, fs_info->sectorsize));

fs/btrfs/relocation.c

1589

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

1646

min_reserved = (reserve_level << fs_info->nodesize_bits) * 2;

fs/btrfs/relocation.c

1650

ret = btrfs_block_rsv_refill(fs_info, rc->block_rsv,

fs/btrfs/relocation.c

1716

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/relocation.c

1743

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/relocation.c

1755

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

1762

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

1763

rc->merging_rsv_size += fs_info->nodesize * (BTRFS_MAX_LEVEL - 1) * 2;

fs/btrfs/relocation.c

1765

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

1770

ret = btrfs_block_rsv_add(fs_info, rc->block_rsv, num_bytes,

fs/btrfs/relocation.c

1779

btrfs_block_rsv_release(fs_info, rc->block_rsv,

fs/btrfs/relocation.c

1787

btrfs_block_rsv_release(fs_info, rc->block_rsv,

fs/btrfs/relocation.c

1800

root = btrfs_get_fs_root(fs_info, reloc_root->root_key.offset,

fs/btrfs/relocation.c

1816

btrfs_err(fs_info,

fs/btrfs/relocation.c

1830

btrfs_err(fs_info,

fs/btrfs/relocation.c

185

static struct reloc_control *get_reloc_control(struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

1882

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

1897

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

1899

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

190

if (!data_race(fs_info->reloc_ctl))

fs/btrfs/relocation.c

1905

root = btrfs_get_fs_root(fs_info, reloc_root->root_key.offset,

fs/btrfs/relocation.c

193

spin_lock(&fs_info->reloc_ctl_lock);

fs/btrfs/relocation.c

194

rc = fs_info->reloc_ctl;

fs/btrfs/relocation.c

197

spin_unlock(&fs_info->reloc_ctl_lock);

fs/btrfs/relocation.c

1979

btrfs_handle_fs_error(fs_info, ret, NULL);

fs/btrfs/relocation.c

1983

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

1985

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

2020

struct btrfs_fs_info *fs_info = reloc_root->fs_info;

fs/btrfs/relocation.c

2027

root = btrfs_get_fs_root(fs_info, reloc_root->root_key.offset, false);

fs/btrfs/relocation.c

2043

btrfs_err(fs_info,

fs/btrfs/relocation.c

2081

btrfs_err(trans->fs_info,

fs/btrfs/relocation.c

2087

btrfs_err(trans->fs_info,

fs/btrfs/relocation.c

2120

btrfs_err(trans->fs_info,

fs/btrfs/relocation.c

218

ASSERT(rc->extent_root->fs_info->reloc_ctl != rc);

fs/btrfs/relocation.c

2197

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

2212

num_bytes += fs_info->nodesize;

fs/btrfs/relocation.c

2230

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

2241

ret = btrfs_block_rsv_refill(fs_info, rc->block_rsv, num_bytes,

fs/btrfs/relocation.c

2244

u64 tmp = fs_info->nodesize * RELOCATION_RESERVED_NODES;

fs/btrfs/relocation.c

2255

rc->block_rsv->size = tmp + fs_info->nodesize *

fs/btrfs/relocation.c

2359

btrfs_err(root->fs_info,

fs/btrfs/relocation.c

236

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

2371

blocksize = root->fs_info->nodesize;

fs/btrfs/relocation.c

242

rc = get_reloc_control(fs_info);

fs/btrfs/relocation.c

2514

u32 blocksize = rc->extent_root->fs_info->nodesize;

fs/btrfs/relocation.c

2522

static int get_tree_block_key(struct btrfs_fs_info *fs_info,

fs/btrfs/relocation.c

2532

eb = read_tree_block(fs_info, block->bytenr, &check);

fs/btrfs/relocation.c

2598

btrfs_err(root->fs_info,

fs/btrfs/relocation.c

2621

btrfs_err(root->fs_info,

fs/btrfs/relocation.c

264

spin_lock(&fs_info->trans_lock);

fs/btrfs/relocation.c

2642

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

2648

root = btrfs_get_fs_root(fs_info, block->owner, true);

fs/btrfs/relocation.c

2654

num_bytes = (nr_levels << fs_info->nodesize_bits);

fs/btrfs/relocation.c

2661

if (root == root->fs_info->chunk_root)

fs/btrfs/relocation.c

2668

if (root == root->fs_info->chunk_root)

fs/btrfs/relocation.c

2684

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

269

spin_unlock(&fs_info->trans_lock);

fs/btrfs/relocation.c

2700

btrfs_readahead_tree_block(fs_info, block->bytenr,

fs/btrfs/relocation.c

2708

ret = get_tree_block_key(fs_info, block);

fs/btrfs/relocation.c

284

blocksize = rc->extent_root->fs_info->nodesize;

fs/btrfs/relocation.c

2848

noinline int btrfs_should_cancel_balance(const struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

2850

return atomic_read(&fs_info->balance_cancel_req) ||

fs/btrfs/relocation.c

2851

atomic_read(&fs_info->reloc_cancel_req) ||

fs/btrfs/relocation.c

2873

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/relocation.c

2884

const bool use_rst = btrfs_need_stripe_tree_update(fs_info, rc->block_group->flags);

fs/btrfs/relocation.c

2977

btrfs_folio_set_dirty(fs_info, folio, clamped_start, clamped_len);

fs/btrfs/relocation.c

2991

fs_info->sectorsize - 1;

fs/btrfs/relocation.c

3014

btrfs_throttle(fs_info);

fs/btrfs/relocation.c

3015

if (btrfs_should_cancel_balance(fs_info))

fs/btrfs/relocation.c

3196

btrfs_err(rc->block_group->fs_info,

fs/btrfs/relocation.c

3212

block->key.objectid = rc->extent_root->fs_info->nodesize;

fs/btrfs/relocation.c

3220

btrfs_backref_panic(rc->extent_root->fs_info, block->bytenr,

fs/btrfs/relocation.c

3233

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

3237

bool skinny = btrfs_fs_incompat(fs_info, SKINNY_METADATA);

fs/btrfs/relocation.c

3285

btrfs_err(fs_info,

fs/btrfs/relocation.c

3298

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/relocation.c

3299

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/relocation.c

3313

ret = btrfs_check_trunc_cache_free_space(fs_info,

fs/btrfs/relocation.c

3314

&fs_info->global_block_rsv);

fs/btrfs/relocation.c

3327

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/relocation.c

3384

const u32 blocksize = rc->extent_root->fs_info->nodesize;

fs/btrfs/relocation.c

3391

ctx.fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

3402

eb = read_tree_block(ctx.fs_info, ref_node->val, &check);

fs/btrfs/relocation.c

3429

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

3483

key.objectid + fs_info->nodesize <=

fs/btrfs/relocation.c

3501

fs_info->nodesize;

fs/btrfs/relocation.c

3512

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

3514

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

3515

spin_lock(&fs_info->reloc_ctl_lock);

fs/btrfs/relocation.c

3516

fs_info->reloc_ctl = rc;

fs/btrfs/relocation.c

3517

spin_unlock(&fs_info->reloc_ctl_lock);

fs/btrfs/relocation.c

3518

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

3523

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

3525

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

3526

spin_lock(&fs_info->reloc_ctl_lock);

fs/btrfs/relocation.c

3527

fs_info->reloc_ctl = NULL;

fs/btrfs/relocation.c

3528

spin_unlock(&fs_info->reloc_ctl_lock);

fs/btrfs/relocation.c

3529

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

3538

rc->block_rsv = btrfs_alloc_block_rsv(rc->extent_root->fs_info,

fs/btrfs/relocation.c

3549

rc->block_rsv->size = rc->extent_root->fs_info->nodesize *

fs/btrfs/relocation.c

3551

ret = btrfs_block_rsv_refill(rc->extent_root->fs_info,

fs/btrfs/relocation.c

3580

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

3604

ret = btrfs_block_rsv_refill(fs_info, rc->block_rsv,

fs/btrfs/relocation.c

3641

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE) {

fs/btrfs/relocation.c

3643

u64 owning_root_id = btrfs_get_extent_owner_root(fs_info,

fs/btrfs/relocation.c

3677

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/relocation.c

3689

if (btrfs_should_cancel_balance(fs_info)) {

fs/btrfs/relocation.c

3708

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/relocation.c

3711

if (!err && !btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/relocation.c

3721

btrfs_block_rsv_release(fs_info, rc->block_rsv, (u64)-1, NULL);

fs/btrfs/relocation.c

3737

btrfs_block_rsv_release(fs_info, rc->block_rsv, (u64)-1, NULL);

fs/btrfs/relocation.c

3747

btrfs_free_block_rsv(fs_info, rc->block_rsv);

fs/btrfs/relocation.c

3813

struct btrfs_fs_info *fs_info = group->fs_info;

fs/btrfs/relocation.c

3820

root = btrfs_grab_root(fs_info->data_reloc_root);

fs/btrfs/relocation.c

3848

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/relocation.c

386

root->fs_info->running_transaction->transid)

fs/btrfs/relocation.c

3867

static int reloc_chunk_start(struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

3869

if (test_and_set_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags)) {

fs/btrfs/relocation.c

3871

btrfs_err(fs_info, "reloc already running, cannot start");

fs/btrfs/relocation.c

3875

if (atomic_read(&fs_info->reloc_cancel_req) > 0) {

fs/btrfs/relocation.c

3876

btrfs_info(fs_info, "chunk relocation canceled on start");

fs/btrfs/relocation.c

3878

clear_and_wake_up_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags);

fs/btrfs/relocation.c

3879

atomic_set(&fs_info->reloc_cancel_req, 0);

fs/btrfs/relocation.c

3889

static void reloc_chunk_end(struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

3891

ASSERT(test_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags));

fs/btrfs/relocation.c

3893

if (atomic_read(&fs_info->reloc_cancel_req) > 0)

fs/btrfs/relocation.c

3894

btrfs_info(fs_info, "chunk relocation canceled during operation");

fs/btrfs/relocation.c

3895

clear_and_wake_up_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags);

fs/btrfs/relocation.c

3896

atomic_set(&fs_info->reloc_cancel_req, 0);

fs/btrfs/relocation.c

3899

static struct reloc_control *alloc_reloc_control(struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

3909

btrfs_backref_init_cache(fs_info, &rc->backref_cache, true);

fs/btrfs/relocation.c

3912

btrfs_extent_io_tree_init(fs_info, &rc->processed_blocks, IO_TREE_RELOC_BLOCKS);

fs/btrfs/relocation.c

3927

btrfs_info(block_group->fs_info, "relocating block group %llu flags %s",

fs/btrfs/relocation.c

3944

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

3949

max_items = BTRFS_LEAF_DATA_SIZE(trans->fs_info) / sizeof(struct btrfs_item);

fs/btrfs/relocation.c

3961

ret = btrfs_insert_empty_items(trans, fs_info->remap_root, path, &batch);

fs/btrfs/relocation.c

399

struct btrfs_root *find_reloc_root(struct btrfs_fs_info *fs_info, u64 bytenr)

fs/btrfs/relocation.c

401

struct reloc_control *rc = fs_info->reloc_ctl;

fs/btrfs/relocation.c

4020

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4043

btrfs_inc_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/relocation.c

4066

static int copy_remapped_data_io(struct btrfs_fs_info *fs_info,

fs/btrfs/relocation.c

4078

bbio = btrfs_bio_alloc(BIO_MAX_VECS, op, BTRFS_I(fs_info->btree_inode),

fs/btrfs/relocation.c

4092

BTRFS_I(fs_info->btree_inode),

fs/btrfs/relocation.c

4113

static int copy_remapped_data(struct btrfs_fs_info *fs_info, u64 old_addr,

fs/btrfs/relocation.c

4139

ret = copy_remapped_data_io(fs_info, &priv, pages, old_addr,

fs/btrfs/relocation.c

4144

ret = copy_remapped_data_io(fs_info, &priv, pages, new_addr,

fs/btrfs/relocation.c

4172

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4182

ret = btrfs_insert_empty_item(trans, fs_info->remap_root, path,

fs/btrfs/relocation.c

4201

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4211

ret = btrfs_insert_empty_item(trans, fs_info->remap_root, path, &key,

fs/btrfs/relocation.c

4226

static int move_existing_remap(struct btrfs_fs_info *fs_info,

fs/btrfs/relocation.c

4249

min_size = fs_info->sectorsize;

fs/btrfs/relocation.c

4251

min_size = fs_info->nodesize;

fs/btrfs/relocation.c

4253

ret = btrfs_reserve_extent(fs_info->fs_root, length, length, min_size,

fs/btrfs/relocation.c

4271

dest_bg = btrfs_lookup_block_group(fs_info, dest_addr);

fs/btrfs/relocation.c

4273

if (!is_data && !IS_ALIGNED(dest_length, fs_info->nodesize)) {

fs/btrfs/relocation.c

4274

u64 new_length = ALIGN_DOWN(dest_length, fs_info->nodesize);

fs/btrfs/relocation.c

4276

btrfs_free_reserved_extent(fs_info, dest_addr + new_length,

fs/btrfs/relocation.c

4282

trans = btrfs_join_transaction(fs_info->remap_root);

fs/btrfs/relocation.c

4289

mutex_lock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

4297

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, 0, 1);

fs/btrfs/relocation.c

4312

ret = copy_remapped_data(fs_info, new_addr, dest_addr, dest_length);

fs/btrfs/relocation.c

4342

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, -1, 1);

fs/btrfs/relocation.c

4354

ret = btrfs_del_item(trans, fs_info->remap_root, path);

fs/btrfs/relocation.c

4406

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

4408

btrfs_dec_block_group_reservations(fs_info, dest_addr);

fs/btrfs/relocation.c

4411

btrfs_free_reserved_extent(fs_info, dest_addr, dest_length, 0);

fs/btrfs/relocation.c

4428

static int move_existing_remaps(struct btrfs_fs_info *fs_info,

fs/btrfs/relocation.c

4444

ret = btrfs_search_slot(NULL, fs_info->remap_root, &key, path, 0, 0);

fs/btrfs/relocation.c

4451

ret = btrfs_next_leaf(fs_info->remap_root, path);

fs/btrfs/relocation.c

4471

ret = btrfs_next_leaf(fs_info->remap_root, path);

fs/btrfs/relocation.c

4493

ret = move_existing_remap(fs_info, path, bg, key.objectid,

fs/btrfs/relocation.c

4508

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4602

parse_bitmap(fs_info->sectorsize, bitmap,

fs/btrfs/relocation.c

4690

struct btrfs_root *remap_root = trans->fs_info->remap_root;

fs/btrfs/relocation.c

4742

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4754

ret = btrfs_search_slot(trans, fs_info->chunk_root, &key, path, 0, 1);

fs/btrfs/relocation.c

4783

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/relocation.c

4803

trans = btrfs_start_transaction_fallback_global_rsv(fs_info->tree_root, num_items);

fs/btrfs/relocation.c

4814

mutex_lock(&trans->fs_info->chunk_mutex);

fs/btrfs/relocation.c

4818

mutex_unlock(&trans->fs_info->chunk_mutex);

fs/btrfs/relocation.c

4824

mutex_unlock(&trans->fs_info->chunk_mutex);

fs/btrfs/relocation.c

4826

write_lock(&trans->fs_info->mapping_tree_lock);

fs/btrfs/relocation.c

4828

write_unlock(&trans->fs_info->mapping_tree_lock);

fs/btrfs/relocation.c

4853

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4881

btrfs_inc_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/relocation.c

4892

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4901

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, -1, 1);

fs/btrfs/relocation.c

4923

ret = btrfs_del_item(trans, fs_info->remap_root, path);

fs/btrfs/relocation.c

4949

ret = btrfs_insert_empty_item(trans, fs_info->remap_root,

fs/btrfs/relocation.c

4976

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4984

read_lock(&fs_info->mapping_tree_lock);

fs/btrfs/relocation.c

4986

chunk_map = btrfs_find_chunk_map_nolock(fs_info, start, 1);

fs/btrfs/relocation.c

4988

read_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/relocation.c

4995

read_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/relocation.c

5001

ret = btrfs_search_slot(trans, fs_info->chunk_root, &key, path, 0, 1);

fs/btrfs/relocation.c

5022

static int do_remap_reloc_trans(struct btrfs_fs_info *fs_info,

fs/btrfs/relocation.c

5038

extent_root = btrfs_extent_root(fs_info, src_bg->start);

fs/btrfs/relocation.c

5040

btrfs_err(fs_info,

fs/btrfs/relocation.c

5050

mutex_lock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

5058

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

5069

min_size = fs_info->sectorsize;

fs/btrfs/relocation.c

5071

min_size = fs_info->nodesize;

fs/btrfs/relocation.c

5082

ret = btrfs_reserve_extent(fs_info->fs_root, remap_length, remap_length,

fs/btrfs/relocation.c

5089

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

5105

if (!is_data && !IS_ALIGNED(length, fs_info->nodesize)) {

fs/btrfs/relocation.c

5106

u64 new_length = ALIGN_DOWN(length, fs_info->nodesize);

fs/btrfs/relocation.c

5108

btrfs_free_reserved_extent(fs_info, new_addr + new_length,

fs/btrfs/relocation.c

5114

dest_bg = btrfs_lookup_block_group(fs_info, new_addr);

fs/btrfs/relocation.c

5129

ret = copy_remapped_data(fs_info, start, new_addr, length);

fs/btrfs/relocation.c

5159

btrfs_dec_block_group_reservations(fs_info, new_addr);

fs/btrfs/relocation.c

5161

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

5192

btrfs_free_reserved_extent(fs_info, new_addr, length, 0);

fs/btrfs/relocation.c

5194

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

5200

static int do_remap_reloc(struct btrfs_fs_info *fs_info, struct btrfs_path *path,

fs/btrfs/relocation.c

5207

ret = do_remap_reloc_trans(fs_info, bg, path, &last_start);

fs/btrfs/relocation.c

5218

int btrfs_translate_remap(struct btrfs_fs_info *fs_info, u64 *logical, u64 *length)

fs/btrfs/relocation.c

5234

ret = btrfs_search_slot(NULL, fs_info->remap_root, &key, path, 0, 0);

fs/btrfs/relocation.c

5268

static int start_block_group_remapping(struct btrfs_fs_info *fs_info,

fs/btrfs/relocation.c

5280

trans = btrfs_start_transaction(fs_info->remap_root, 0);

fs/btrfs/relocation.c

5291

mutex_lock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

5318

btrfs_inc_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/relocation.c

5335

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

5344

static int do_nonremap_reloc(struct btrfs_fs_info *fs_info, bool verbose,

fs/btrfs/relocation.c

5352

mutex_lock(&fs_info->cleaner_mutex);

fs/btrfs/relocation.c

5354

mutex_unlock(&fs_info->cleaner_mutex);

fs/btrfs/relocation.c

5384

btrfs_info(fs_info, "found %llu extents, stage: %s",

fs/btrfs/relocation.c

5398

int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 group_start,

fs/btrfs/relocation.c

5402

struct btrfs_root *extent_root = btrfs_extent_root(fs_info, group_start);

fs/btrfs/relocation.c

5410

btrfs_err(fs_info,

fs/btrfs/relocation.c

5421

ret = wait_on_bit(&fs_info->flags, BTRFS_FS_UNFINISHED_DROPS, TASK_INTERRUPTIBLE);

fs/btrfs/relocation.c

5426

if (btrfs_fs_closing(fs_info))

fs/btrfs/relocation.c

5429

bg = btrfs_lookup_block_group(fs_info, group_start);

fs/btrfs/relocation.c

5442

ASSERT(sb_write_started(fs_info->sb));

fs/btrfs/relocation.c

5444

if (btrfs_pinned_by_swapfile(fs_info, bg)) {

fs/btrfs/relocation.c

5449

rc = alloc_reloc_control(fs_info);

fs/btrfs/relocation.c

5459

ret = reloc_chunk_start(fs_info);

fs/btrfs/relocation.c

5485

if (!btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/relocation.c

5499

btrfs_wait_ordered_roots(fs_info, U64_MAX, rc->block_group);

fs/btrfs/relocation.c

5506

ret = move_existing_remaps(fs_info, bg, path);

fs/btrfs/relocation.c

5510

ret = start_block_group_remapping(fs_info, path, bg);

fs/btrfs/relocation.c

5514

ret = do_remap_reloc(fs_info, path, rc->block_group);

fs/btrfs/relocation.c

5518

btrfs_delete_unused_bgs(fs_info);

fs/btrfs/relocation.c

5520

ret = do_nonremap_reloc(fs_info, verbose, rc);

fs/btrfs/relocation.c

5526

if (!btrfs_fs_incompat(fs_info, REMAP_TREE))

fs/btrfs/relocation.c

5529

reloc_chunk_end(fs_info);

fs/btrfs/relocation.c

5537

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

5541

trans = btrfs_start_transaction(fs_info->tree_root, 0);

fs/btrfs/relocation.c

5549

ret = btrfs_update_root(trans, fs_info->tree_root,

fs/btrfs/relocation.c

5564

int btrfs_recover_relocation(struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

5587

ret = btrfs_search_slot(NULL, fs_info->tree_root, &key,

fs/btrfs/relocation.c

5605

reloc_root = btrfs_read_tree_root(fs_info->tree_root, &key);

fs/btrfs/relocation.c

5615

fs_root = btrfs_get_fs_root(fs_info,

fs/btrfs/relocation.c

5640

rc = alloc_reloc_control(fs_info);

fs/btrfs/relocation.c

5646

rc->extent_root = btrfs_extent_root(fs_info, 0);

fs/btrfs/relocation.c

5648

btrfs_err(fs_info, "missing extent root for extent at bytenr 0");

fs/btrfs/relocation.c

5653

ret = reloc_chunk_start(fs_info);

fs/btrfs/relocation.c

5677

fs_root = btrfs_get_fs_root(fs_info, reloc_root->root_key.offset,

fs/btrfs/relocation.c

5718

reloc_chunk_end(fs_info);

fs/btrfs/relocation.c

5726

if (ret == 0 && !btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/relocation.c

5728

fs_root = btrfs_grab_root(fs_info->data_reloc_root);

fs/btrfs/relocation.c

573

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

5745

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/relocation.c

5747

struct btrfs_root *csum_root = btrfs_csum_root(fs_info, disk_bytenr);

fs/btrfs/relocation.c

5753

btrfs_err(fs_info,

fs/btrfs/relocation.c

5797

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

5804

rc = get_reloc_control(fs_info);

fs/btrfs/relocation.c

5826

btrfs_err(fs_info,

fs/btrfs/relocation.c

5867

struct reloc_control *rc = root->fs_info->reloc_ctl;

fs/btrfs/relocation.c

588

btrfs_err(fs_info,

fs/btrfs/relocation.c

5907

rc = get_reloc_control(trans->fs_info);

fs/btrfs/relocation.c

5950

u64 btrfs_get_reloc_bg_bytenr(struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

5954

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

5955

if (fs_info->reloc_ctl && fs_info->reloc_ctl->block_group)

fs/btrfs/relocation.c

5956

logical = fs_info->reloc_ctl->block_group->start;

fs/btrfs/relocation.c

5957

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

5966

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

5976

ret = btrfs_insert_empty_item(trans, fs_info->remap_root, path,

fs/btrfs/relocation.c

5986

ret = btrfs_insert_empty_item(trans, fs_info->remap_root,

fs/btrfs/relocation.c

6004

ret = btrfs_insert_empty_item(trans, fs_info->remap_root,

fs/btrfs/relocation.c

6032

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

605

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

6060

ret = btrfs_del_item(trans, fs_info->remap_root, path);

fs/btrfs/relocation.c

6073

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, -1, 1);

fs/btrfs/relocation.c

608

struct reloc_control *rc = fs_info->reloc_ctl;

fs/btrfs/relocation.c

6082

ret = btrfs_del_item(trans, fs_info->remap_root, path);

fs/btrfs/relocation.c

6122

dest_bg = btrfs_lookup_block_group(fs_info, new_addr);

fs/btrfs/relocation.c

6148

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

6154

if (!(btrfs_super_incompat_flags(fs_info->super_copy) &

fs/btrfs/relocation.c

6158

bg = btrfs_lookup_block_group(fs_info, bytenr);

fs/btrfs/relocation.c

6162

mutex_lock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

6165

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

6175

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, -1, 1);

fs/btrfs/relocation.c

6214

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

628

btrfs_backref_panic(fs_info, node->bytenr, -EEXIST);

fs/btrfs/relocation.c

635

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

665

btrfs_err(fs_info,

fs/btrfs/relocation.c

721

ret = btrfs_insert_root(trans, fs_info->tree_root,

fs/btrfs/relocation.c

728

reloc_root = btrfs_read_tree_root(fs_info->tree_root, &root_key);

fs/btrfs/relocation.c

748

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

755

rc = get_reloc_control(fs_info);

fs/btrfs/relocation.c

819

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

838

rc = get_reloc_control(fs_info);

fs/btrfs/relocation.c

857

ret = btrfs_update_root(trans, fs_info->tree_root,

fs/btrfs/relocation.c

873

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

896

btrfs_err(fs_info,

fs/btrfs/relocation.c

913

btrfs_err(fs_info,

fs/btrfs/relocation.c

937

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

998

fs_info->sectorsize));

fs/btrfs/relocation.c

999

WARN_ON(!IS_ALIGNED(end, fs_info->sectorsize));

fs/btrfs/relocation.h

17

if (!btrfs_fs_incompat(bg->fs_info, REMAP_TREE))

fs/btrfs/relocation.h

26

int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 group_start,

fs/btrfs/relocation.h

31

int btrfs_recover_relocation(struct btrfs_fs_info *fs_info);

fs/btrfs/relocation.h

41

int btrfs_should_cancel_balance(const struct btrfs_fs_info *fs_info);

fs/btrfs/relocation.h

42

struct btrfs_root *find_reloc_root(struct btrfs_fs_info *fs_info, u64 bytenr);

fs/btrfs/relocation.h

44

u64 btrfs_get_reloc_bg_bytenr(struct btrfs_fs_info *fs_info);

fs/btrfs/relocation.h

45

int btrfs_translate_remap(struct btrfs_fs_info *fs_info, u64 *logical, u64 *length);

fs/btrfs/root-tree.c

132

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/root-tree.c

149

btrfs_crit(fs_info,

fs/btrfs/root-tree.c

213

int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/root-tree.c

215

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/root-tree.c

257

root = btrfs_get_fs_root(fs_info, root_objectid, false);

fs/btrfs/root-tree.c

267

btrfs_err(fs_info,

fs/btrfs/root-tree.c

275

btrfs_err(fs_info,

fs/btrfs/root-tree.c

295

set_bit(BTRFS_FS_UNFINISHED_DROPS, &fs_info->flags);

fs/btrfs/root-tree.c

312

struct btrfs_root *root = trans->fs_info->tree_root;

fs/btrfs/root-tree.c

333

struct btrfs_root *tree_root = trans->fs_info->tree_root;

fs/btrfs/root-tree.c

40

btrfs_warn(eb->fs_info,

fs/btrfs/root-tree.c

401

struct btrfs_root *tree_root = trans->fs_info->tree_root;

fs/btrfs/root-tree.c

497

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/root-tree.c

498

struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;

fs/btrfs/root-tree.c

500

if (btrfs_qgroup_enabled(fs_info)) {

fs/btrfs/root-tree.c

502

qgroup_num_bytes = 3 * fs_info->nodesize;

fs/btrfs/root-tree.c

510

num_bytes = btrfs_calc_insert_metadata_size(fs_info, items);

fs/btrfs/root-tree.c

511

rsv->space_info = btrfs_find_space_info(fs_info,

fs/btrfs/root-tree.c

513

ret = btrfs_block_rsv_add(fs_info, rsv, num_bytes,

fs/btrfs/root-tree.h

36

int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info);

fs/btrfs/scrub.c

1000

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

1021

u64 mapped_len = fs_info->sectorsize;

fs/btrfs/scrub.c

1028

ret = btrfs_map_block(fs_info, BTRFS_MAP_GET_READ_MIRRORS,

fs/btrfs/scrub.c

1070

btrfs_err_rl(fs_info,

fs/btrfs/scrub.c

1075

btrfs_err_rl(fs_info,

fs/btrfs/scrub.c

1084

btrfs_err_rl(fs_info,

fs/btrfs/scrub.c

1089

btrfs_err_rl(fs_info,

fs/btrfs/scrub.c

1119

i += (fs_info->nodesize >> fs_info->sectorsize_bits))

fs/btrfs/scrub.c

1125

sctx->stat.data_bytes_scrubbed += nr_data_sectors << fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1126

sctx->stat.tree_bytes_scrubbed += nr_meta_sectors << fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1158

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

1160

int num_copies = btrfs_num_copies(fs_info, stripe->bg->start,

fs/btrfs/scrub.c

1217

fs_info->sectorsize, true);

fs/btrfs/scrub.c

1232

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/scrub.c

1233

btrfs_repair_one_zone(fs_info, sctx->stripes[0].bg->start);

fs/btrfs/scrub.c

1253

num_sectors = bio_size >> stripe->bg->fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1265

queue_work(stripe->bg->fs_info->scrub_workers, &stripe->work);

fs/btrfs/scrub.c

1272

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

1281

bio_size >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

1283

for (int i = 0; i < (bio_size >> fs_info->sectorsize_bits); i++)

fs/btrfs/scrub.c

1297

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

1305

if (!btrfs_is_zoned(fs_info))

fs/btrfs/scrub.c

1317

if (!test_bit(bio_off >> fs_info->sectorsize_bits,

fs/btrfs/scrub.c

1338

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

1352

bbio = alloc_scrub_bbio(fs_info, stripe->nr_sectors, REQ_OP_WRITE,

fs/btrfs/scrub.c

1353

stripe->logical + (sector_nr << fs_info->sectorsize_bits),

fs/btrfs/scrub.c

1468

struct btrfs_fs_info *fs_info = path->nodes[0]->fs_info;

fs/btrfs/scrub.c

1476

len = fs_info->nodesize;

fs/btrfs/scrub.c

1507

struct btrfs_fs_info *fs_info = extent_root->fs_info;

fs/btrfs/scrub.c

1516

if (btrfs_fs_incompat(fs_info, SKINNY_METADATA))

fs/btrfs/scrub.c

1582

*size_ret = path->nodes[0]->fs_info->nodesize;

fs/btrfs/scrub.c

1593

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

1596

if (!btrfs_is_zoned(fs_info))

fs/btrfs/scrub.c

1605

btrfs_err(fs_info, "scrub: zoned: failed to recover write pointer");

fs/btrfs/scrub.c

1613

static void fill_one_extent_info(struct btrfs_fs_info *fs_info,

fs/btrfs/scrub.c

1621

cur_logical += fs_info->sectorsize) {

fs/btrfs/scrub.c

1623

fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1656

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/scrub.c

1657

struct btrfs_root *extent_root = btrfs_extent_root(fs_info, bg->start);

fs/btrfs/scrub.c

1658

struct btrfs_root *csum_root = btrfs_csum_root(fs_info, bg->start);

fs/btrfs/scrub.c

1669

btrfs_err(fs_info, "scrub: no valid extent or csum root found");

fs/btrfs/scrub.c

1709

fill_one_extent_info(fs_info, stripe, extent_start, extent_len,

fs/btrfs/scrub.c

1729

fill_one_extent_info(fs_info, stripe, extent_start, extent_len,

fs/btrfs/scrub.c

1746

ASSERT(BITS_PER_LONG >= BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

1758

sector_nr * fs_info->csum_size;

fs/btrfs/scrub.c

1790

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

1792

unsigned int nr_sectors = stripe_length(stripe) >> fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1819

(i << fs_info->sectorsize_bits);

fs/btrfs/scrub.c

1823

stripe_len = (nr_sectors - i) << fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1828

ret = btrfs_map_block(fs_info, BTRFS_MAP_READ, logical,

fs/btrfs/scrub.c

1847

bbio = alloc_scrub_bbio(fs_info, stripe->nr_sectors, REQ_OP_READ,

fs/btrfs/scrub.c

1863

queue_work(stripe->bg->fs_info->scrub_workers, &stripe->work);

fs/btrfs/scrub.c

1870

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

1872

const u32 min_folio_shift = PAGE_SHIFT + fs_info->block_min_order;

fs/btrfs/scrub.c

1873

unsigned int nr_sectors = stripe_length(stripe) >> fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1880

if (btrfs_need_stripe_tree_update(fs_info, stripe->bg->flags)) {

fs/btrfs/scrub.c

1885

bbio = alloc_scrub_bbio(fs_info, BTRFS_STRIPE_LEN >> min_folio_shift, REQ_OP_READ,

fs/btrfs/scrub.c

1897

(fs_info->dev_replace.cont_reading_from_srcdev_mode ==

fs/btrfs/scrub.c

1900

int num_copies = btrfs_num_copies(fs_info, stripe->bg->start,

fs/btrfs/scrub.c

1915

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

1917

btrfs_err(fs_info,

fs/btrfs/scrub.c

1920

stripe->logical + (i << fs_info->sectorsize_bits));

fs/btrfs/scrub.c

1951

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

196

struct btrfs_fs_info *fs_info;

fs/btrfs/scrub.c

1994

ASSERT(stripe->dev == fs_info->dev_replace.srcdev);

fs/btrfs/scrub.c

2073

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2075

if (atomic_read(&fs_info->scrub_cancel_req) ||

fs/btrfs/scrub.c

2097

if (fs_info->sb->s_writers.frozen > SB_UNFROZEN ||

fs/btrfs/scrub.c

2110

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2123

btrfs_bio_counter_inc_blocked(fs_info);

fs/btrfs/scrub.c

2124

ret = btrfs_map_block(fs_info, BTRFS_MAP_WRITE, full_stripe_start,

fs/btrfs/scrub.c

2131

BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

2148

btrfs_bio_counter_dec(fs_info);

fs/btrfs/scrub.c

2159

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2174

if (atomic_read(&fs_info->scrub_pause_req))

fs/btrfs/scrub.c

2175

scrub_blocked_if_needed(fs_info);

fs/btrfs/scrub.c

2249

ASSERT(!btrfs_is_zoned(sctx->fs_info));

fs/btrfs/scrub.c

2273

btrfs_err(fs_info,

fs/btrfs/scrub.c

2302

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2319

if (atomic_read(&fs_info->scrub_pause_req))

fs/btrfs/scrub.c

2320

scrub_blocked_if_needed(fs_info);

fs/btrfs/scrub.c

2431

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2450

scrub_blocked_if_needed(fs_info);

fs/btrfs/scrub.c

2470

ret = init_scrub_stripe(fs_info,

fs/btrfs/scrub.c

2593

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2598

map = btrfs_find_chunk_map(fs_info, bg->start, bg->length);

fs/btrfs/scrub.c

2633

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/scrub.c

2635

if (!btrfs_is_zoned(fs_info))

fs/btrfs/scrub.c

2640

btrfs_wait_ordered_roots(fs_info, U64_MAX, cache);

fs/btrfs/scrub.c

2651

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2652

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/scrub.c

2661

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/scrub.c

2725

cache = btrfs_lookup_block_group(fs_info, chunk_offset);

fs/btrfs/scrub.c

2757

if (sctx->is_dev_replace && btrfs_is_zoned(fs_info)) {

fs/btrfs/scrub.c

2789

scrub_pause_on(fs_info);

fs/btrfs/scrub.c

2826

scrub_pause_off(fs_info);

fs/btrfs/scrub.c

2851

btrfs_warn(fs_info,

fs/btrfs/scrub.c

2854

scrub_pause_off(fs_info);

fs/btrfs/scrub.c

2858

btrfs_warn(fs_info, "scrub: failed setting block group ro: %d",

fs/btrfs/scrub.c

2862

scrub_pause_off(fs_info);

fs/btrfs/scrub.c

2873

btrfs_wait_ordered_roots(fs_info, U64_MAX, cache);

fs/btrfs/scrub.c

2876

scrub_pause_off(fs_info);

fs/btrfs/scrub.c

2909

if (btrfs_test_opt(fs_info, DISCARD_ASYNC))

fs/btrfs/scrub.c

2910

btrfs_discard_queue_work(&fs_info->discard_ctl,

fs/btrfs/scrub.c

2942

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2950

ret = btrfs_check_super_csum(fs_info, sb);

fs/btrfs/scrub.c

2952

btrfs_err_rl(fs_info,

fs/btrfs/scrub.c

2958

btrfs_err_rl(fs_info,

fs/btrfs/scrub.c

2965

return btrfs_validate_super(fs_info, sb, -1);

fs/btrfs/scrub.c

2976

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2978

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/scrub.c

2990

if (scrub_dev->fs_devices != fs_info->fs_devices)

fs/btrfs/scrub.c

2993

gen = btrfs_get_last_trans_committed(fs_info);

fs/btrfs/scrub.c

3024

static void scrub_workers_put(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

3026

if (refcount_dec_and_mutex_lock(&fs_info->scrub_workers_refcnt,

fs/btrfs/scrub.c

3027

&fs_info->scrub_lock)) {

fs/btrfs/scrub.c

3028

struct workqueue_struct *scrub_workers = fs_info->scrub_workers;

fs/btrfs/scrub.c

3030

fs_info->scrub_workers = NULL;

fs/btrfs/scrub.c

3031

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3041

static noinline_for_stack int scrub_workers_get(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

3045

int max_active = fs_info->thread_pool_size;

fs/btrfs/scrub.c

3048

if (refcount_inc_not_zero(&fs_info->scrub_workers_refcnt))

fs/btrfs/scrub.c

3055

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3056

if (refcount_read(&fs_info->scrub_workers_refcnt) == 0) {

fs/btrfs/scrub.c

3057

ASSERT(fs_info->scrub_workers == NULL);

fs/btrfs/scrub.c

3058

fs_info->scrub_workers = scrub_workers;

fs/btrfs/scrub.c

3059

refcount_set(&fs_info->scrub_workers_refcnt, 1);

fs/btrfs/scrub.c

3060

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3064

refcount_inc(&fs_info->scrub_workers_refcnt);

fs/btrfs/scrub.c

3065

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3073

int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,

fs/btrfs/scrub.c

3088

if (btrfs_fs_closing(fs_info))

fs/btrfs/scrub.c

3092

ASSERT(fs_info->nodesize <= BTRFS_STRIPE_LEN);

fs/btrfs/scrub.c

3099

ASSERT(fs_info->nodesize <=

fs/btrfs/scrub.c

3100

SCRUB_MAX_SECTORS_PER_BLOCK << fs_info->sectorsize_bits);

fs/btrfs/scrub.c

3103

sctx = scrub_setup_ctx(fs_info, is_dev_replace);

fs/btrfs/scrub.c

3108

ret = scrub_workers_get(fs_info);

fs/btrfs/scrub.c

3112

mutex_lock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/scrub.c

3113

dev = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/scrub.c

3116

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/scrub.c

3123

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/scrub.c

3124

btrfs_err(fs_info,

fs/btrfs/scrub.c

3131

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3134

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3135

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/scrub.c

3140

down_read(&fs_info->dev_replace.rwsem);

fs/btrfs/scrub.c

3143

btrfs_dev_replace_is_ongoing(&fs_info->dev_replace))) {

fs/btrfs/scrub.c

3144

up_read(&fs_info->dev_replace.rwsem);

fs/btrfs/scrub.c

3145

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3146

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/scrub.c

3150

up_read(&fs_info->dev_replace.rwsem);

fs/btrfs/scrub.c

3154

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/scrub.c

3160

__scrub_blocked_if_needed(fs_info);

fs/btrfs/scrub.c

3161

atomic_inc(&fs_info->scrubs_running);

fs/btrfs/scrub.c

3162

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3181

btrfs_info(fs_info, "scrub: started on devid %llu", devid);

fs/btrfs/scrub.c

3186

mutex_lock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/scrub.c

3188

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/scrub.c

3205

atomic_dec(&fs_info->scrubs_running);

fs/btrfs/scrub.c

3206

wake_up(&fs_info->scrub_pause_wait);

fs/btrfs/scrub.c

3212

btrfs_info(fs_info, "scrub: %s on devid %llu with status: %d",

fs/btrfs/scrub.c

3215

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3217

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3219

scrub_workers_put(fs_info);

fs/btrfs/scrub.c

3229

trans = btrfs_start_transaction(fs_info->tree_root, 0);

fs/btrfs/scrub.c

3232

btrfs_err(fs_info,

fs/btrfs/scrub.c

3238

btrfs_err(fs_info,

fs/btrfs/scrub.c

3243

scrub_workers_put(fs_info);

fs/btrfs/scrub.c

3250

void btrfs_scrub_pause(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

3252

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3253

atomic_inc(&fs_info->scrub_pause_req);

fs/btrfs/scrub.c

3254

while (atomic_read(&fs_info->scrubs_paused) !=

fs/btrfs/scrub.c

3255

atomic_read(&fs_info->scrubs_running)) {

fs/btrfs/scrub.c

3256

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3257

wait_event(fs_info->scrub_pause_wait,

fs/btrfs/scrub.c

3258

atomic_read(&fs_info->scrubs_paused) ==

fs/btrfs/scrub.c

3259

atomic_read(&fs_info->scrubs_running));

fs/btrfs/scrub.c

3260

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3262

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3265

void btrfs_scrub_continue(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

3267

atomic_dec(&fs_info->scrub_pause_req);

fs/btrfs/scrub.c

3268

wake_up(&fs_info->scrub_pause_wait);

fs/btrfs/scrub.c

3271

int btrfs_scrub_cancel(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

3273

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3274

if (!atomic_read(&fs_info->scrubs_running)) {

fs/btrfs/scrub.c

3275

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3279

atomic_inc(&fs_info->scrub_cancel_req);

fs/btrfs/scrub.c

3280

while (atomic_read(&fs_info->scrubs_running)) {

fs/btrfs/scrub.c

3281

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3282

wait_event(fs_info->scrub_pause_wait,

fs/btrfs/scrub.c

3283

atomic_read(&fs_info->scrubs_running) == 0);

fs/btrfs/scrub.c

3284

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3286

atomic_dec(&fs_info->scrub_cancel_req);

fs/btrfs/scrub.c

3287

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3294

struct btrfs_fs_info *fs_info = dev->fs_info;

fs/btrfs/scrub.c

3297

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3300

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3305

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3306

wait_event(fs_info->scrub_pause_wait,

fs/btrfs/scrub.c

3308

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3310

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3315

int btrfs_scrub_progress(struct btrfs_fs_info *fs_info, u64 devid,

fs/btrfs/scrub.c

3322

mutex_lock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/scrub.c

3323

dev = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/scrub.c

3328

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/scrub.c

354

static int init_scrub_stripe(struct btrfs_fs_info *fs_info,

fs/btrfs/scrub.c

357

const u32 min_folio_shift = PAGE_SHIFT + fs_info->block_min_order;

fs/btrfs/scrub.c

362

stripe->nr_sectors = BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits;

fs/btrfs/scrub.c

372

fs_info->block_min_order, stripe->folios,

fs/btrfs/scrub.c

382

stripe->csums = kcalloc(BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits,

fs/btrfs/scrub.c

383

fs_info->csum_size, GFP_KERNEL);

fs/btrfs/scrub.c

399

static void __scrub_blocked_if_needed(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

401

while (atomic_read(&fs_info->scrub_pause_req)) {

fs/btrfs/scrub.c

402

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

403

wait_event(fs_info->scrub_pause_wait,

fs/btrfs/scrub.c

404

atomic_read(&fs_info->scrub_pause_req) == 0);

fs/btrfs/scrub.c

405

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

409

static void scrub_pause_on(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

411

atomic_inc(&fs_info->scrubs_paused);

fs/btrfs/scrub.c

412

wake_up(&fs_info->scrub_pause_wait);

fs/btrfs/scrub.c

415

static void scrub_pause_off(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

417

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

418

__scrub_blocked_if_needed(fs_info);

fs/btrfs/scrub.c

419

atomic_dec(&fs_info->scrubs_paused);

fs/btrfs/scrub.c

420

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

422

wake_up(&fs_info->scrub_pause_wait);

fs/btrfs/scrub.c

425

static void scrub_blocked_if_needed(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

427

scrub_pause_on(fs_info);

fs/btrfs/scrub.c

428

scrub_pause_off(fs_info);

fs/btrfs/scrub.c

451

struct btrfs_fs_info *fs_info, bool is_dev_replace)

fs/btrfs/scrub.c

464

sctx->fs_info = fs_info;

fs/btrfs/scrub.c

472

ret = init_scrub_stripe(fs_info, &sctx->stripes[i]);

fs/btrfs/scrub.c

485

WARN_ON(!fs_info->dev_replace.tgtdev);

fs/btrfs/scrub.c

486

sctx->wr_tgtdev = fs_info->dev_replace.tgtdev;

fs/btrfs/scrub.c

506

struct btrfs_fs_info *fs_info = swarn->dev->fs_info;

fs/btrfs/scrub.c

511

local_root = btrfs_get_fs_root(fs_info, root, true);

fs/btrfs/scrub.c

561

btrfs_warn(fs_info,

fs/btrfs/scrub.c

567

fs_info->sectorsize, nlink,

fs/btrfs/scrub.c

574

btrfs_warn(fs_info,

fs/btrfs/scrub.c

587

struct btrfs_fs_info *fs_info = dev->fs_info;

fs/btrfs/scrub.c

599

btrfs_warn(fs_info, "scrub: %s on device %s, physical %llu",

fs/btrfs/scrub.c

612

ret = extent_from_logical(fs_info, swarn.logical, path, &found_key,

fs/btrfs/scrub.c

633

btrfs_warn(fs_info,

fs/btrfs/scrub.c

640

btrfs_warn(fs_info,

fs/btrfs/scrub.c

654

ctx.fs_info = fs_info;

fs/btrfs/scrub.c

668

if (!btrfs_is_zoned(sctx->fs_info))

fs/btrfs/scrub.c

687

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

688

const u32 min_folio_shift = PAGE_SHIFT + fs_info->block_min_order;

fs/btrfs/scrub.c

689

u32 offset = (sector_nr << fs_info->sectorsize_bits);

fs/btrfs/scrub.c

700

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

701

const u32 min_folio_shift = PAGE_SHIFT + fs_info->block_min_order;

fs/btrfs/scrub.c

702

u32 offset = (sector_nr << fs_info->sectorsize_bits);

fs/btrfs/scrub.c

709

ASSERT(offset_in_folio(folio, offset) + fs_info->sectorsize <= folio_size(folio));

fs/btrfs/scrub.c

715

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

716

const u32 sectors_per_tree = fs_info->nodesize >> fs_info->sectorsize_bits;

fs/btrfs/scrub.c

717

const u64 logical = stripe->logical + (sector_nr << fs_info->sectorsize_bits);

fs/btrfs/scrub.c

729

memcpy(on_disk_csum, header->csum, fs_info->csum_size);

fs/btrfs/scrub.c

734

btrfs_warn_rl(fs_info,

fs/btrfs/scrub.c

740

if (memcmp(header->fsid, fs_info->fs_devices->metadata_uuid,

fs/btrfs/scrub.c

744

btrfs_warn_rl(fs_info,

fs/btrfs/scrub.c

747

header->fsid, fs_info->fs_devices->metadata_uuid);

fs/btrfs/scrub.c

750

if (memcmp(header->chunk_tree_uuid, fs_info->chunk_tree_uuid,

fs/btrfs/scrub.c

754

btrfs_warn_rl(fs_info,

fs/btrfs/scrub.c

757

header->chunk_tree_uuid, fs_info->chunk_tree_uuid);

fs/btrfs/scrub.c

762

btrfs_csum_init(&csum, fs_info->csum_type);

fs/btrfs/scrub.c

764

fs_info->sectorsize - BTRFS_CSUM_SIZE);

fs/btrfs/scrub.c

768

fs_info->sectorsize);

fs/btrfs/scrub.c

772

if (memcmp(calculated_csum, on_disk_csum, fs_info->csum_size) != 0) {

fs/btrfs/scrub.c

775

btrfs_warn_rl(fs_info,

fs/btrfs/scrub.c

778

BTRFS_CSUM_FMT_VALUE(fs_info->csum_size, on_disk_csum),

fs/btrfs/scrub.c

779

BTRFS_CSUM_FMT_VALUE(fs_info->csum_size, calculated_csum));

fs/btrfs/scrub.c

786

btrfs_warn_rl(fs_info,

fs/btrfs/scrub.c

801

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

803

const u32 sectors_per_tree = fs_info->nodesize >> fs_info->sectorsize_bits;

fs/btrfs/scrub.c

829

btrfs_warn_rl(fs_info,

fs/btrfs/scrub.c

832

(sector_nr << fs_info->sectorsize_bits),

fs/btrfs/scrub.c

849

ret = btrfs_check_block_csum(fs_info, paddr, csum_buf, sector->csum);

fs/btrfs/scrub.c

862

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

863

const u32 sectors_per_tree = fs_info->nodesize >> fs_info->sectorsize_bits;

fs/btrfs/scrub.c

894

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

902

bio_size >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

904

bio_size >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

907

bio_size >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

923

struct btrfs_fs_info *fs_info = bbio->inode->root->fs_info;

fs/btrfs/scrub.c

927

ret = bio_add_page(&bbio->bio, virt_to_page(kaddr), fs_info->sectorsize,

fs/btrfs/scrub.c

937

ASSERT(ret == fs_info->sectorsize);

fs/btrfs/scrub.c

940

static struct btrfs_bio *alloc_scrub_bbio(struct btrfs_fs_info *fs_info,

fs/btrfs/scrub.c

947

bbio = btrfs_bio_alloc(nr_vecs, opf, BTRFS_I(fs_info->btree_inode),

fs/btrfs/scrub.c

957

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

979

bbio = alloc_scrub_bbio(fs_info, stripe->nr_sectors, REQ_OP_READ,

fs/btrfs/scrub.c

980

stripe->logical + (i << fs_info->sectorsize_bits),

fs/btrfs/scrub.h

12

int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,

fs/btrfs/scrub.h

15

void btrfs_scrub_pause(struct btrfs_fs_info *fs_info);

fs/btrfs/scrub.h

16

void btrfs_scrub_continue(struct btrfs_fs_info *fs_info);

fs/btrfs/scrub.h

19

int btrfs_scrub_progress(struct btrfs_fs_info *fs_info, u64 devid,

fs/btrfs/send.c

1054

btrfs_err(root->fs_info,

fs/btrfs/send.c

1138

BTRFS_MAX_XATTR_SIZE(root->fs_info))) {

fs/btrfs/send.c

1376

struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;

fs/btrfs/send.c

1377

const u64 key = leaf_bytenr >> fs_info->nodesize_bits;

fs/btrfs/send.c

1395

if (fs_info->last_reloc_trans > sctx->backref_cache_last_reloc_trans) {

fs/btrfs/send.c

1416

struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;

fs/btrfs/send.c

1432

new_entry->entry.key = leaf_bytenr >> fs_info->nodesize_bits;

fs/btrfs/send.c

1480

sctx->backref_cache_last_reloc_trans = fs_info->last_reloc_trans;

fs/btrfs/send.c

1547

struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;

fs/btrfs/send.c

1619

backref_walk_ctx.fs_info = fs_info;

fs/btrfs/send.c

1642

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

1643

if (fs_info->last_reloc_trans > sctx->last_reloc_trans) {

fs/btrfs/send.c

1656

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

1659

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

1731

btrfs_err(root->fs_info,

fs/btrfs/send.c

1742

btrfs_crit(root->fs_info,

fs/btrfs/send.c

1750

btrfs_crit(root->fs_info,

fs/btrfs/send.c

2461

ret = btrfs_search_slot_for_read(send_root->fs_info->tree_root,

fs/btrfs/send.c

2811

btrfs_warn(sctx->send_root->fs_info, "unexpected inode type %o",

fs/btrfs/send.c

401

btrfs_err(sctx->send_root->fs_info,

fs/btrfs/send.c

4135

struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;

fs/btrfs/send.c

4156

btrfs_err(fs_info,

fs/btrfs/send.c

4782

btrfs_err(sctx->send_root->fs_info,

fs/btrfs/send.c

5174

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/send.c

5215

btrfs_err(fs_info,

fs/btrfs/send.c

5453

struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;

fs/btrfs/send.c

5481

ret = btrfs_encoded_io_compression_from_extent(fs_info,

fs/btrfs/send.c

5504

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/send.c

5544

ret = btrfs_encoded_io_compression_from_extent(fs_info,

fs/btrfs/send.c

5787

len == sctx->send_root->fs_info->sectorsize)

fs/btrfs/send.c

6036

u64 bs = sctx->send_root->fs_info->sectorsize;

fs/btrfs/send.c

7137

lockdep_assert_not_held(&sctx->send_root->fs_info->commit_root_sem);

fs/btrfs/send.c

7211

lockdep_assert_held_read(&root->fs_info->commit_root_sem);

fs/btrfs/send.c

7224

btrfs_err(root->fs_info,

fs/btrfs/send.c

7241

struct btrfs_fs_info *fs_info = send_root->fs_info;

fs/btrfs/send.c

7253

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7254

sctx->last_reloc_trans = fs_info->last_reloc_trans;

fs/btrfs/send.c

7255

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7271

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7272

if (fs_info->last_reloc_trans > sctx->last_reloc_trans) {

fs/btrfs/send.c

7273

sctx->last_reloc_trans = fs_info->last_reloc_trans;

fs/btrfs/send.c

7274

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7290

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7329

lockdep_assert_held_read(&parent->fs_info->commit_root_sem);

fs/btrfs/send.c

7342

reada_max = (*level == 1 ? SZ_128K : eb->fs_info->nodesize);

fs/btrfs/send.c

7347

reada_done += eb->fs_info->nodesize;

fs/btrfs/send.c

7478

lockdep_assert_held_read(&sctx->send_root->fs_info->commit_root_sem);

fs/btrfs/send.c

7555

struct btrfs_fs_info *fs_info = left_root->fs_info;

fs/btrfs/send.c

7588

tmp_buf = kvmalloc(fs_info->nodesize, GFP_KERNEL);

fs/btrfs/send.c

7635

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7682

sctx->last_reloc_trans = fs_info->last_reloc_trans;

fs/btrfs/send.c

7686

rwsem_is_contended(&fs_info->commit_root_sem)) {

fs/btrfs/send.c

7687

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7689

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7692

if (fs_info->last_reloc_trans > sctx->last_reloc_trans) {

fs/btrfs/send.c

7699

sctx->last_reloc_trans = fs_info->last_reloc_trans;

fs/btrfs/send.c

7730

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7737

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7743

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7750

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7757

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7789

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7830

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

785

btrfs_err(sctx->send_root->fs_info,

fs/btrfs/send.c

7938

btrfs_err(root->fs_info,

fs/btrfs/send.c

7946

btrfs_warn_rl(root->fs_info,

fs/btrfs/send.c

7954

struct btrfs_fs_info *fs_info = send_root->fs_info;

fs/btrfs/send.c

8116

clone_root = btrfs_get_fs_root(fs_info,

fs/btrfs/send.c

8148

sctx->parent_root = btrfs_get_fs_root(fs_info, arg->parent_root,

fs/btrfs/space-info.c

1084

ordered = percpu_counter_read_positive(&fs_info->ordered_bytes) >> 1;

fs/btrfs/space-info.c

1085

delalloc = percpu_counter_read_positive(&fs_info->delalloc_bytes);

fs/btrfs/space-info.c

1087

used += btrfs_block_rsv_reserved(&fs_info->delayed_refs_rsv) +

fs/btrfs/space-info.c

1088

btrfs_block_rsv_reserved(&fs_info->delayed_block_rsv);

fs/btrfs/space-info.c

1092

return (used >= thresh && !btrfs_fs_closing(fs_info) &&

fs/btrfs/space-info.c

1093

!test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state));

fs/btrfs/space-info.c

1099

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1100

struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;

fs/btrfs/space-info.c

1145

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1148

const int abort_error = BTRFS_FS_ERROR(fs_info);

fs/btrfs/space-info.c

1150

trace_btrfs_fail_all_tickets(fs_info, space_info);

fs/btrfs/space-info.c

1152

if (btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {

fs/btrfs/space-info.c

1153

btrfs_info(fs_info, "cannot satisfy tickets, dumping space info");

fs/btrfs/space-info.c

1167

if (btrfs_test_opt(fs_info, ENOSPC_DEBUG))

fs/btrfs/space-info.c

1168

btrfs_info(fs_info, "failing ticket with %llu bytes",

fs/btrfs/space-info.c

1187

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1194

if (btrfs_is_zoned(fs_info))

fs/btrfs/space-info.c

1273

struct btrfs_fs_info *fs_info;

fs/btrfs/space-info.c

1276

fs_info = container_of(work, struct btrfs_fs_info, async_reclaim_work);

fs/btrfs/space-info.c

1277

space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);

fs/btrfs/space-info.c

1295

struct btrfs_fs_info *fs_info;

fs/btrfs/space-info.c

1303

fs_info = container_of(work, struct btrfs_fs_info,

fs/btrfs/space-info.c

1305

space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);

fs/btrfs/space-info.c

1306

delayed_block_rsv = &fs_info->delayed_block_rsv;

fs/btrfs/space-info.c

1307

delayed_refs_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/space-info.c

1308

global_rsv = &fs_info->global_block_rsv;

fs/btrfs/space-info.c

1309

trans_rsv = &fs_info->trans_block_rsv;

fs/btrfs/space-info.c

1373

to_reclaim = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/space-info.c

1382

trace_btrfs_done_preemptive_reclaim(fs_info, space_info);

fs/btrfs/space-info.c

1441

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1464

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/space-info.c

1498

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/space-info.c

1514

struct btrfs_fs_info *fs_info;

fs/btrfs/space-info.c

1517

fs_info = container_of(work, struct btrfs_fs_info, async_data_reclaim_work);

fs/btrfs/space-info.c

1518

space_info = fs_info->data_sinfo;

fs/btrfs/space-info.c

1525

void btrfs_init_async_reclaim_work(struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

1527

INIT_WORK(&fs_info->async_reclaim_work, btrfs_async_reclaim_metadata_space);

fs/btrfs/space-info.c

1528

INIT_WORK(&fs_info->async_data_reclaim_work, btrfs_async_reclaim_data_space);

fs/btrfs/space-info.c

1529

INIT_WORK(&fs_info->preempt_reclaim_work,

fs/btrfs/space-info.c

1569

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1602

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/space-info.c

1603

remove_ticket(space_info, ticket, BTRFS_FS_ERROR(fs_info));

fs/btrfs/space-info.c

1726

trace_btrfs_reserve_ticket(space_info->fs_info, space_info->flags,

fs/btrfs/space-info.c

1743

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1744

u64 ordered = percpu_counter_sum_positive(&fs_info->ordered_bytes);

fs/btrfs/space-info.c

1745

u64 delalloc = percpu_counter_sum_positive(&fs_info->delalloc_bytes);

fs/btrfs/space-info.c

1792

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1815

async_work = &fs_info->async_data_reclaim_work;

fs/btrfs/space-info.c

1817

async_work = &fs_info->async_reclaim_work;

fs/btrfs/space-info.c

1889

trace_btrfs_trigger_flush(fs_info,

fs/btrfs/space-info.c

1905

if (!test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags) &&

fs/btrfs/space-info.c

1906

!work_busy(&fs_info->preempt_reclaim_work) &&

fs/btrfs/space-info.c

1908

trace_btrfs_trigger_flush(fs_info, space_info->flags,

fs/btrfs/space-info.c

1911

&fs_info->preempt_reclaim_work);

fs/btrfs/space-info.c

1943

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1945

trace_btrfs_space_reservation(fs_info, "space_info:enospc",

fs/btrfs/space-info.c

1948

if (btrfs_test_opt(fs_info, ENOSPC_DEBUG))

fs/btrfs/space-info.c

1967

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1980

trace_btrfs_space_reservation(fs_info, "space_info:enospc",

fs/btrfs/space-info.c

1982

if (btrfs_test_opt(fs_info, ENOSPC_DEBUG))

fs/btrfs/space-info.c

1989

__cold void btrfs_dump_space_info_for_trans_abort(struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

1993

btrfs_info(fs_info, "dumping space info:");

fs/btrfs/space-info.c

1994

list_for_each_entry(space_info, &fs_info->space_info, list) {

fs/btrfs/space-info.c

1999

dump_global_block_rsv(fs_info);

fs/btrfs/space-info.c

2062

static u64 calc_unalloc_target(struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

2064

u64 chunk_sz = calc_effective_data_chunk_size(fs_info);

fs/btrfs/space-info.c

2094

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

2095

u64 unalloc = atomic64_read(&fs_info->free_chunk_space);

fs/btrfs/space-info.c

2096

u64 target = calc_unalloc_target(fs_info);

fs/btrfs/space-info.c

2101

u64 data_chunk_size = calc_effective_data_chunk_size(fs_info);

fs/btrfs/space-info.c

2127

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

2128

u64 unalloc = atomic64_read(&fs_info->free_chunk_space);

fs/btrfs/space-info.c

2129

u64 data_chunk_size = calc_effective_data_chunk_size(fs_info);

fs/btrfs/space-info.c

2184

u64 chunk_sz = calc_effective_data_chunk_size(space_info->fs_info);

fs/btrfs/space-info.c

220

static u64 calc_chunk_size(const struct btrfs_fs_info *fs_info, u64 flags)

fs/btrfs/space-info.c

222

if (btrfs_is_zoned(fs_info))

fs/btrfs/space-info.c

2222

void btrfs_reclaim_sweep(const struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

2227

list_for_each_entry(space_info, &fs_info->space_info, list) {

fs/btrfs/space-info.c

223

return fs_info->zone_size;

fs/btrfs/space-info.c

2242

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

2243

struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;

fs/btrfs/space-info.c

233

if (fs_info->fs_devices->total_rw_bytes > 50ULL * SZ_1G)

fs/btrfs/space-info.c

251

space_info->fs_info = info;

fs/btrfs/space-info.c

272

struct btrfs_fs_info *fs_info = parent->fs_info;

fs/btrfs/space-info.c

284

init_space_info(fs_info, sub_group, flags);

fs/btrfs/space-info.c

336

int btrfs_init_space_info(struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

344

disk_super = fs_info->super_copy;

fs/btrfs/space-info.c

353

ret = create_space_info(fs_info, flags);

fs/btrfs/space-info.c

359

ret = create_space_info(fs_info, flags);

fs/btrfs/space-info.c

364

ret = create_space_info(fs_info, flags);

fs/btrfs/space-info.c

369

ret = create_space_info(fs_info, flags);

fs/btrfs/space-info.c

376

ret = create_space_info(fs_info, flags);

fs/btrfs/space-info.c

430

static u64 calc_effective_data_chunk_size(const struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

444

data_sinfo = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_DATA);

fs/btrfs/space-info.c

445

if (btrfs_is_zoned(fs_info))

fs/btrfs/space-info.c

448

mult_perc(fs_info->fs_devices->total_rw_bytes, 10));

fs/btrfs/space-info.c

455

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

463

profile = btrfs_system_alloc_profile(fs_info);

fs/btrfs/space-info.c

465

profile = btrfs_metadata_alloc_profile(fs_info);

fs/btrfs/space-info.c

467

has_per_profile = btrfs_get_per_profile_avail(fs_info, profile, &avail);

fs/btrfs/space-info.c

469

avail = atomic64_read(&fs_info->free_chunk_space);

fs/btrfs/space-info.c

482

data_chunk_size = calc_effective_data_chunk_size(fs_info);

fs/btrfs/space-info.c

518

if (btrfs_is_zoned(fs_info))

fs/btrfs/space-info.c

519

avail = ALIGN_DOWN(avail, fs_info->zone_size);

fs/btrfs/space-info.c

626

#define DUMP_BLOCK_RSV(fs_info, rsv_name) \

fs/btrfs/space-info.c

628

struct btrfs_block_rsv *__rsv = &(fs_info)->rsv_name; \

fs/btrfs/space-info.c

630

btrfs_info(fs_info, #rsv_name ": size %llu reserved %llu", \

fs/btrfs/space-info.c

635

static void dump_global_block_rsv(struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

637

DUMP_BLOCK_RSV(fs_info, global_block_rsv);

fs/btrfs/space-info.c

638

DUMP_BLOCK_RSV(fs_info, trans_block_rsv);

fs/btrfs/space-info.c

639

DUMP_BLOCK_RSV(fs_info, chunk_block_rsv);

fs/btrfs/space-info.c

640

DUMP_BLOCK_RSV(fs_info, remap_block_rsv);

fs/btrfs/space-info.c

641

DUMP_BLOCK_RSV(fs_info, delayed_block_rsv);

fs/btrfs/space-info.c

642

DUMP_BLOCK_RSV(fs_info, delayed_refs_rsv);

fs/btrfs/space-info.c

647

const struct btrfs_fs_info *fs_info = info->fs_info;

fs/btrfs/space-info.c

652

btrfs_info(fs_info,

fs/btrfs/space-info.c

657

btrfs_info(fs_info,

fs/btrfs/space-info.c

667

struct btrfs_fs_info *fs_info = info->fs_info;

fs/btrfs/space-info.c

674

dump_global_block_rsv(fs_info);

fs/btrfs/space-info.c

687

btrfs_info(fs_info,

fs/btrfs/space-info.c

701

btrfs_info(fs_info, "%llu bytes available across all block groups", total_avail);

fs/btrfs/space-info.c

704

static inline u64 calc_reclaim_items_nr(const struct btrfs_fs_info *fs_info,

fs/btrfs/space-info.c

710

bytes = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/space-info.c

724

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

732

delalloc_bytes = percpu_counter_sum_positive(&fs_info->delalloc_bytes);

fs/btrfs/space-info.c

733

ordered_bytes = percpu_counter_sum_positive(&fs_info->ordered_bytes);

fs/btrfs/space-info.c

754

items = calc_reclaim_items_nr(fs_info, to_reclaim) * 2;

fs/btrfs/space-info.c

773

btrfs_start_delalloc_roots(fs_info, nr_pages, true);

fs/btrfs/space-info.c

796

async_pages = atomic_read(&fs_info->async_delalloc_pages);

fs/btrfs/space-info.c

810

wait_event(fs_info->async_submit_wait,

fs/btrfs/space-info.c

811

atomic_read(&fs_info->async_delalloc_pages) <=

fs/btrfs/space-info.c

816

btrfs_wait_ordered_roots(fs_info, items, NULL);

fs/btrfs/space-info.c

840

&fs_info->delalloc_bytes);

fs/btrfs/space-info.c

842

&fs_info->ordered_bytes);

fs/btrfs/space-info.c

854

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

855

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/space-info.c

864

nr = calc_reclaim_items_nr(fs_info, num_bytes) * 2;

fs/btrfs/space-info.c

909

btrfs_get_alloc_profile(fs_info, space_info->flags),

fs/btrfs/space-info.c

918

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/space-info.c

919

btrfs_reclaim_sweep(fs_info);

fs/btrfs/space-info.c

920

btrfs_delete_unused_bgs(fs_info);

fs/btrfs/space-info.c

921

btrfs_reclaim_block_groups(fs_info,

fs/btrfs/space-info.c

935

btrfs_run_delayed_iputs(fs_info);

fs/btrfs/space-info.c

936

btrfs_wait_on_delayed_iputs(fs_info);

fs/btrfs/space-info.c

957

trace_btrfs_flush_space(fs_info, space_info->flags, num_bytes, state,

fs/btrfs/space-info.c

987

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

988

const u64 global_rsv_size = btrfs_block_rsv_reserved(&fs_info->global_block_rsv);

fs/btrfs/space-info.h

138

struct btrfs_fs_info *fs_info;

fs/btrfs/space-info.h

271

struct btrfs_fs_info *fs_info = sinfo->fs_info; \

fs/btrfs/space-info.h

274

trace_update_##name(fs_info, sinfo, sinfo->name, bytes); \

fs/btrfs/space-info.h

275

trace_btrfs_space_reservation(fs_info, trace_name, \

fs/btrfs/space-info.h

301

int btrfs_init_space_info(struct btrfs_fs_info *fs_info);

fs/btrfs/space-info.h

329

void btrfs_dump_space_info_for_trans_abort(struct btrfs_fs_info *fs_info);

fs/btrfs/space-info.h

330

void btrfs_init_async_reclaim_work(struct btrfs_fs_info *fs_info);

fs/btrfs/space-info.h

336

void btrfs_reclaim_sweep(const struct btrfs_fs_info *fs_info);

fs/btrfs/subpage.c

120

void btrfs_folio_inc_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio)

fs/btrfs/subpage.c

124

if (!btrfs_meta_is_subpage(fs_info))

fs/btrfs/subpage.c

134

void btrfs_folio_dec_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio)

fs/btrfs/subpage.c

138

if (!btrfs_meta_is_subpage(fs_info))

fs/btrfs/subpage.c

149

static void btrfs_subpage_assert(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

154

ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&

fs/btrfs/subpage.c

155

IS_ALIGNED(len, fs_info->sectorsize), "start=%llu len=%u", start, len);

fs/btrfs/subpage.c

167

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

fs/btrfs/subpage.c

170

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

172

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

fs/btrfs/subpage.c

173

__start_bit = offset_in_folio(folio, start) >> fs_info->sectorsize_bits; \

fs/btrfs/subpage.c

195

static bool btrfs_subpage_end_and_test_lock(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

199

const int nbits = (len >> fs_info->sectorsize_bits);

fs/btrfs/subpage.c

203

btrfs_subpage_assert(fs_info, folio, start, len);

fs/btrfs/subpage.c

241

void btrfs_folio_end_lock(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

248

if (unlikely(!fs_info) || !btrfs_is_subpage(fs_info, folio)) {

fs/btrfs/subpage.c

267

if (btrfs_subpage_end_and_test_lock(fs_info, folio, start, len))

fs/btrfs/subpage.c

271

void btrfs_folio_end_lock_bitmap(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

275

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/subpage.c

280

if (!btrfs_is_subpage(fs_info, folio)) {

fs/btrfs/subpage.c

301

#define subpage_test_bitmap_all_set(fs_info, folio, name) \

fs/btrfs/subpage.c

304

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

310

#define subpage_test_bitmap_all_zero(fs_info, folio, name) \

fs/btrfs/subpage.c

313

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

319

void btrfs_subpage_set_uptodate(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

323

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

328

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

fs/btrfs/subpage.c

329

if (subpage_test_bitmap_all_set(fs_info, folio, uptodate))

fs/btrfs/subpage.c

334

void btrfs_subpage_clear_uptodate(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

338

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

343

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

fs/btrfs/subpage.c

348

void btrfs_subpage_set_dirty(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

352

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

357

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

fs/btrfs/subpage.c

38

int btrfs_attach_folio_state(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

389

bool btrfs_subpage_clear_and_test_dirty(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

393

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

399

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

fs/btrfs/subpage.c

400

if (subpage_test_bitmap_all_zero(fs_info, folio, dirty))

fs/btrfs/subpage.c

406

void btrfs_subpage_clear_dirty(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

411

last = btrfs_subpage_clear_and_test_dirty(fs_info, folio, start, len);

fs/btrfs/subpage.c

416

void btrfs_subpage_set_writeback(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

420

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

425

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

fs/btrfs/subpage.c

443

void btrfs_subpage_clear_writeback(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

447

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

452

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

fs/btrfs/subpage.c

453

if (subpage_test_bitmap_all_zero(fs_info, folio, writeback)) {

fs/btrfs/subpage.c

465

bool btrfs_subpage_test_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

469

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio, \

fs/btrfs/subpage.c

476

len >> fs_info->sectorsize_bits); \

fs/btrfs/subpage.c

491

void btrfs_folio_set_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

494

if (unlikely(!fs_info) || \

fs/btrfs/subpage.c

495

!btrfs_is_subpage(fs_info, folio)) { \

fs/btrfs/subpage.c

499

btrfs_subpage_set_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

501

void btrfs_folio_clear_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

504

if (unlikely(!fs_info) || \

fs/btrfs/subpage.c

505

!btrfs_is_subpage(fs_info, folio)) { \

fs/btrfs/subpage.c

509

btrfs_subpage_clear_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

511

bool btrfs_folio_test_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

514

if (unlikely(!fs_info) || \

fs/btrfs/subpage.c

515

!btrfs_is_subpage(fs_info, folio)) \

fs/btrfs/subpage.c

517

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

fs/btrfs/subpage.c

519

void btrfs_folio_clamp_set_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

522

if (unlikely(!fs_info) || \

fs/btrfs/subpage.c

523

!btrfs_is_subpage(fs_info, folio)) { \

fs/btrfs/subpage.c

528

btrfs_subpage_set_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

530

void btrfs_folio_clamp_clear_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

533

if (unlikely(!fs_info) || \

fs/btrfs/subpage.c

534

!btrfs_is_subpage(fs_info, folio)) { \

fs/btrfs/subpage.c

539

btrfs_subpage_clear_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

541

bool btrfs_folio_clamp_test_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

544

if (unlikely(!fs_info) || \

fs/btrfs/subpage.c

545

!btrfs_is_subpage(fs_info, folio)) \

fs/btrfs/subpage.c

548

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

fs/btrfs/subpage.c

552

if (!btrfs_meta_is_subpage(eb->fs_info)) { \

fs/btrfs/subpage.c

556

btrfs_subpage_set_##name(eb->fs_info, folio, eb->start, eb->len); \

fs/btrfs/subpage.c

560

if (!btrfs_meta_is_subpage(eb->fs_info)) { \

fs/btrfs/subpage.c

564

btrfs_subpage_clear_##name(eb->fs_info, folio, eb->start, eb->len); \

fs/btrfs/subpage.c

568

if (!btrfs_meta_is_subpage(eb->fs_info)) \

fs/btrfs/subpage.c

57

if (type == BTRFS_SUBPAGE_METADATA && !btrfs_meta_is_subpage(fs_info))

fs/btrfs/subpage.c

570

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

fs/btrfs/subpage.c

581

const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

584

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

59

if (type == BTRFS_SUBPAGE_DATA && !btrfs_is_subpage(fs_info, folio))

fs/btrfs/subpage.c

594

const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

597

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

611

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

fs/btrfs/subpage.c

613

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

616

unsigned long bitmap = get_bitmap_value_##name(fs_info, folio); \

fs/btrfs/subpage.c

618

btrfs_warn(fs_info, \

fs/btrfs/subpage.c

62

bfs = btrfs_alloc_folio_state(fs_info, folio_size(folio), type);

fs/btrfs/subpage.c

622

btrfs_warn(fs_info, \

fs/btrfs/subpage.c

625

get_bitmap_pointer_##name(fs_info, folio)); \

fs/btrfs/subpage.c

633

void btrfs_folio_assert_not_dirty(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

644

if (!btrfs_is_subpage(fs_info, folio)) {

fs/btrfs/subpage.c

649

start_bit = subpage_calc_start_bit(fs_info, folio, dirty, start, len);

fs/btrfs/subpage.c

650

nbits = len >> fs_info->sectorsize_bits;

fs/btrfs/subpage.c

655

SUBPAGE_DUMP_BITMAP(fs_info, folio, dirty, start, len);

fs/btrfs/subpage.c

669

void btrfs_folio_set_lock(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

678

if (unlikely(!fs_info) || !btrfs_is_subpage(fs_info, folio))

fs/btrfs/subpage.c

682

nbits = len >> fs_info->sectorsize_bits;

fs/btrfs/subpage.c

685

ASSERT(ret <= btrfs_blocks_per_folio(fs_info, folio));

fs/btrfs/subpage.c

698

if (!btrfs_meta_is_subpage(eb->fs_info)) {

fs/btrfs/subpage.c

70

void btrfs_detach_folio_state(const struct btrfs_fs_info *fs_info, struct folio *folio,

fs/btrfs/subpage.c

703

last = btrfs_subpage_clear_and_test_dirty(eb->fs_info, folio, eb->start, eb->len);

fs/btrfs/subpage.c

711

void __cold btrfs_subpage_dump_bitmap(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

715

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/subpage.c

730

uptodate = get_bitmap_value_uptodate(fs_info, folio);

fs/btrfs/subpage.c

731

dirty = get_bitmap_value_dirty(fs_info, folio);

fs/btrfs/subpage.c

732

writeback = get_bitmap_value_writeback(fs_info, folio);

fs/btrfs/subpage.c

736

btrfs_warn(fs_info,

fs/btrfs/subpage.c

746

btrfs_warn(fs_info,

fs/btrfs/subpage.c

749

blocks_per_folio, get_bitmap_pointer_uptodate(fs_info, folio),

fs/btrfs/subpage.c

750

blocks_per_folio, get_bitmap_pointer_dirty(fs_info, folio),

fs/btrfs/subpage.c

751

blocks_per_folio, get_bitmap_pointer_writeback(fs_info, folio));

fs/btrfs/subpage.c

755

void btrfs_copy_subpage_dirty_bitmap(struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

760

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/subpage.c

78

if (type == BTRFS_SUBPAGE_METADATA && !btrfs_meta_is_subpage(fs_info))

fs/btrfs/subpage.c

783

bitmap_copy(dst, get_bitmap_pointer_dirty(fs_info, folio),

fs/btrfs/subpage.c

80

if (type == BTRFS_SUBPAGE_DATA && !btrfs_is_subpage(fs_info, folio))

fs/btrfs/subpage.c

88

struct btrfs_folio_state *btrfs_alloc_folio_state(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

94

ASSERT(fs_info->sectorsize < fsize);

fs/btrfs/subpage.c

98

(fsize >> fs_info->sectorsize_bits)));

fs/btrfs/subpage.h

100

void btrfs_detach_folio_state(const struct btrfs_fs_info *fs_info, struct folio *folio,

fs/btrfs/subpage.h

104

struct btrfs_folio_state *btrfs_alloc_folio_state(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

111

void btrfs_folio_inc_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio);

fs/btrfs/subpage.h

112

void btrfs_folio_dec_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio);

fs/btrfs/subpage.h

114

void btrfs_folio_end_lock(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

116

void btrfs_folio_set_lock(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

118

void btrfs_folio_end_lock_bitmap(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

142

void btrfs_subpage_set_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

144

void btrfs_subpage_clear_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

146

bool btrfs_subpage_test_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

148

void btrfs_folio_set_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

150

void btrfs_folio_clear_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

152

bool btrfs_folio_test_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

154

void btrfs_folio_clamp_set_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

156

void btrfs_folio_clamp_clear_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

158

bool btrfs_folio_clamp_test_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

172

static inline void btrfs_folio_clamp_finish_io(struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

176

btrfs_folio_clamp_clear_dirty(fs_info, locked_folio, start, len);

fs/btrfs/subpage.h

177

btrfs_folio_clamp_set_writeback(fs_info, locked_folio, start, len);

fs/btrfs/subpage.h

178

btrfs_folio_clamp_clear_writeback(fs_info, locked_folio, start, len);

fs/btrfs/subpage.h

181

bool btrfs_subpage_clear_and_test_dirty(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

184

void btrfs_folio_assert_not_dirty(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

187

void btrfs_copy_subpage_dirty_bitmap(struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

190

void __cold btrfs_subpage_dump_bitmap(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

86

static inline bool btrfs_meta_is_subpage(const struct btrfs_fs_info *fs_info)

fs/btrfs/subpage.h

88

return fs_info->nodesize < PAGE_SIZE;

fs/btrfs/subpage.h

90

static inline bool btrfs_is_subpage(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

95

return fs_info->sectorsize < folio_size(folio);

fs/btrfs/subpage.h

98

int btrfs_attach_folio_state(const struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

1008

close_ctree(fs_info);

fs/btrfs/super.c

1015

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

1016

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/super.c

1018

trace_btrfs_sync_fs(fs_info, wait);

fs/btrfs/super.c

1021

filemap_flush(fs_info->btree_inode->i_mapping);

fs/btrfs/super.c

1025

btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);

fs/btrfs/super.c

1036

&fs_info->flags))

fs/btrfs/super.c

1204

struct btrfs_fs_info *fs_info = btrfs_sb(s);

fs/btrfs/super.c

1210

btrfs_err(fs_info, "'%s' is not a valid subvolume",

fs/btrfs/super.c

1220

btrfs_err(fs_info,

fs/btrfs/super.c

1238

static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

1244

fs_info->thread_pool_size = new_pool_size;

fs/btrfs/super.c

1246

btrfs_info(fs_info, "resize thread pool %d -> %d",

fs/btrfs/super.c

1249

btrfs_workqueue_set_max(fs_info->workers, new_pool_size);

fs/btrfs/super.c

1250

btrfs_workqueue_set_max(fs_info->delalloc_workers, new_pool_size);

fs/btrfs/super.c

1251

btrfs_workqueue_set_max(fs_info->caching_workers, new_pool_size);

fs/btrfs/super.c

1252

workqueue_set_max_active(fs_info->endio_workers, new_pool_size);

fs/btrfs/super.c

1253

workqueue_set_max_active(fs_info->endio_meta_workers, new_pool_size);

fs/btrfs/super.c

1254

btrfs_workqueue_set_max(fs_info->endio_write_workers, new_pool_size);

fs/btrfs/super.c

1255

btrfs_workqueue_set_max(fs_info->endio_freespace_worker, new_pool_size);

fs/btrfs/super.c

1256

btrfs_workqueue_set_max(fs_info->delayed_workers, new_pool_size);

fs/btrfs/super.c

1259

static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

1263

(!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||

fs/btrfs/super.c

1266

wait_event(fs_info->transaction_wait,

fs/btrfs/super.c

1267

(atomic_read(&fs_info->defrag_running) == 0));

fs/btrfs/super.c

1269

sync_filesystem(fs_info->sb);

fs/btrfs/super.c

1273

static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

1276

const bool cache_opt = btrfs_test_opt(fs_info, SPACE_CACHE);

fs/btrfs/super.c

1283

(!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) || sb_rdonly(fs_info->sb))) {

fs/btrfs/super.c

1284

btrfs_cleanup_defrag_inodes(fs_info);

fs/btrfs/super.c

1289

btrfs_test_opt(fs_info, DISCARD_ASYNC))

fs/btrfs/super.c

1290

btrfs_discard_resume(fs_info);

fs/btrfs/super.c

1292

!btrfs_test_opt(fs_info, DISCARD_ASYNC))

fs/btrfs/super.c

1293

btrfs_discard_cleanup(fs_info);

fs/btrfs/super.c

1296

if (cache_opt != btrfs_free_space_cache_v1_active(fs_info))

fs/btrfs/super.c

1297

btrfs_set_free_space_cache_v1_active(fs_info, cache_opt);

fs/btrfs/super.c

1300

static int btrfs_remount_rw(struct btrfs_fs_info *fs_info)

fs/btrfs/super.c

1304

if (unlikely(BTRFS_FS_ERROR(fs_info))) {

fs/btrfs/super.c

1305

btrfs_err(fs_info,

fs/btrfs/super.c

1310

if (fs_info->fs_devices->rw_devices == 0)

fs/btrfs/super.c

1313

if (!btrfs_check_rw_degradable(fs_info, NULL)) {

fs/btrfs/super.c

1314

btrfs_warn(fs_info,

fs/btrfs/super.c

1319

if (btrfs_super_log_root(fs_info->super_copy) != 0) {

fs/btrfs/super.c

1320

btrfs_warn(fs_info,

fs/btrfs/super.c

1330

ret = btrfs_start_pre_rw_mount(fs_info);

fs/btrfs/super.c

1334

btrfs_clear_sb_rdonly(fs_info->sb);

fs/btrfs/super.c

1336

set_bit(BTRFS_FS_OPEN, &fs_info->flags);

fs/btrfs/super.c

1342

btrfs_discard_resume(fs_info);

fs/btrfs/super.c

1347

static int btrfs_remount_ro(struct btrfs_fs_info *fs_info)

fs/btrfs/super.c

1353

cancel_work_sync(&fs_info->async_reclaim_work);

fs/btrfs/super.c

1354

cancel_work_sync(&fs_info->async_data_reclaim_work);

fs/btrfs/super.c

1356

btrfs_discard_cleanup(fs_info);

fs/btrfs/super.c

1359

down(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/super.c

1361

up(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/super.c

1363

btrfs_set_sb_rdonly(fs_info->sb);

fs/btrfs/super.c

1371

btrfs_delete_unused_bgs(fs_info);

fs/btrfs/super.c

1383

wait_on_bit(&fs_info->flags, BTRFS_FS_CLEANER_RUNNING, TASK_UNINTERRUPTIBLE);

fs/btrfs/super.c

1392

btrfs_run_delayed_iputs(fs_info);

fs/btrfs/super.c

1394

btrfs_dev_replace_suspend_for_unmount(fs_info);

fs/btrfs/super.c

1395

btrfs_scrub_cancel(fs_info);

fs/btrfs/super.c

1396

btrfs_pause_balance(fs_info);

fs/btrfs/super.c

1404

btrfs_qgroup_wait_for_completion(fs_info, false);

fs/btrfs/super.c

1406

return btrfs_commit_super(fs_info);

fs/btrfs/super.c

1409

static void btrfs_ctx_to_info(struct btrfs_fs_info *fs_info, struct btrfs_fs_context *ctx)

fs/btrfs/super.c

1411

fs_info->max_inline = ctx->max_inline;

fs/btrfs/super.c

1412

fs_info->commit_interval = ctx->commit_interval;

fs/btrfs/super.c

1413

fs_info->metadata_ratio = ctx->metadata_ratio;

fs/btrfs/super.c

1414

fs_info->thread_pool_size = ctx->thread_pool_size;

fs/btrfs/super.c

1415

fs_info->mount_opt = ctx->mount_opt;

fs/btrfs/super.c

1416

fs_info->compress_type = ctx->compress_type;

fs/btrfs/super.c

1417

fs_info->compress_level = ctx->compress_level;

fs/btrfs/super.c

1420

static void btrfs_info_to_ctx(struct btrfs_fs_info *fs_info, struct btrfs_fs_context *ctx)

fs/btrfs/super.c

1422

ctx->max_inline = fs_info->max_inline;

fs/btrfs/super.c

1423

ctx->commit_interval = fs_info->commit_interval;

fs/btrfs/super.c

1424

ctx->metadata_ratio = fs_info->metadata_ratio;

fs/btrfs/super.c

1425

ctx->thread_pool_size = fs_info->thread_pool_size;

fs/btrfs/super.c

1426

ctx->mount_opt = fs_info->mount_opt;

fs/btrfs/super.c

1427

ctx->compress_type = fs_info->compress_type;

fs/btrfs/super.c

1428

ctx->compress_level = fs_info->compress_level;

fs/btrfs/super.c

1431

#define btrfs_info_if_set(fs_info, old_ctx, opt, fmt, args...) \

fs/btrfs/super.c

1434

btrfs_raw_test_opt(fs_info->mount_opt, opt)) \

fs/btrfs/super.c

1435

btrfs_info(fs_info, fmt, ##args); \

fs/btrfs/super.c

1438

#define btrfs_info_if_unset(fs_info, old_ctx, opt, fmt, args...) \

fs/btrfs/super.c

1441

!btrfs_raw_test_opt(fs_info->mount_opt, opt)) \

fs/btrfs/super.c

1442

btrfs_info(fs_info, fmt, ##args); \

fs/btrfs/super.c

1504

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

1510

btrfs_info_to_ctx(fs_info, &old_ctx);

fs/btrfs/super.c

1521

set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);

fs/btrfs/super.c

1523

if (!btrfs_check_options(fs_info, &ctx->mount_opt, fc->sb_flags)) {

fs/btrfs/super.c

1528

ret = btrfs_check_features(fs_info, !(fc->sb_flags & SB_RDONLY));

fs/btrfs/super.c

1532

btrfs_ctx_to_info(fs_info, ctx);

fs/btrfs/super.c

1533

btrfs_remount_begin(fs_info, old_ctx.mount_opt, fc->sb_flags);

fs/btrfs/super.c

1534

btrfs_resize_thread_pool(fs_info, fs_info->thread_pool_size,

fs/btrfs/super.c

1537

if ((bool)btrfs_test_opt(fs_info, FREE_SPACE_TREE) !=

fs/btrfs/super.c

1538

(bool)btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&

fs/btrfs/super.c

1540

btrfs_warn(fs_info,

fs/btrfs/super.c

1543

if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {

fs/btrfs/super.c

1544

btrfs_set_opt(fs_info->mount_opt, FREE_SPACE_TREE);

fs/btrfs/super.c

1545

btrfs_clear_opt(fs_info->mount_opt, SPACE_CACHE);

fs/btrfs/super.c

1547

if (btrfs_free_space_cache_v1_active(fs_info)) {

fs/btrfs/super.c

1548

btrfs_clear_opt(fs_info->mount_opt, FREE_SPACE_TREE);

fs/btrfs/super.c

1549

btrfs_set_opt(fs_info->mount_opt, SPACE_CACHE);

fs/btrfs/super.c

1555

ret = btrfs_remount_ro(fs_info);

fs/btrfs/super.c

1557

ret = btrfs_remount_rw(fs_info);

fs/btrfs/super.c

1569

btrfs_emit_options(fs_info, &old_ctx);

fs/btrfs/super.c

1570

wake_up_process(fs_info->transaction_kthread);

fs/btrfs/super.c

1571

btrfs_remount_cleanup(fs_info, old_ctx.mount_opt);

fs/btrfs/super.c

1572

btrfs_clear_oneshot_options(fs_info);

fs/btrfs/super.c

1573

clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);

fs/btrfs/super.c

1577

btrfs_ctx_to_info(fs_info, &old_ctx);

fs/btrfs/super.c

1578

btrfs_remount_cleanup(fs_info, old_ctx.mount_opt);

fs/btrfs/super.c

1579

clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);

fs/btrfs/super.c

1612

static inline int btrfs_calc_avail_data_space(struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

1616

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/super.c

1629

nr_devices = fs_info->fs_devices->open_devices;

fs/btrfs/super.c

1632

nr_devices = fs_info->fs_devices->open_devices;

fs/btrfs/super.c

1645

type = btrfs_data_alloc_profile(fs_info);

fs/btrfs/super.c

1731

struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);

fs/btrfs/super.c

1732

struct btrfs_super_block *disk_super = fs_info->super_copy;

fs/btrfs/super.c

1737

u32 bits = fs_info->sectorsize_bits;

fs/btrfs/super.c

1740

struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;

fs/btrfs/super.c

1746

list_for_each_entry(found, &fs_info->space_info, list) {

fs/btrfs/super.c

1790

ret = btrfs_calc_avail_data_space(fs_info, &total_free_data);

fs/btrfs/super.c

1823

buf->f_bsize = fs_info->sectorsize;

fs/btrfs/super.c

1831

if (fs_info->fs_devices->temp_fsid)

fs/btrfs/super.c

1832

fsid = (__be32 *)fs_info->super_copy->fsid;

fs/btrfs/super.c

1834

fsid = (__be32 *)fs_info->fs_devices->fsid;

fs/btrfs/super.c

1849

if (fs_info->fs_devices->total_devices == 1) {

fs/btrfs/super.c

1851

u64_to_fsid(huge_encode_dev(fs_info->fs_devices->latest_dev->bdev->bd_dev));

fs/btrfs/super.c

1865

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

1867

return fs_info->fs_devices == p->fs_devices;

fs/btrfs/super.c

1872

struct btrfs_fs_info *fs_info = fc->s_fs_info;

fs/btrfs/super.c

1880

btrfs_ctx_to_info(fs_info, ctx);

fs/btrfs/super.c

1902

fs_info->fs_devices = fs_devices;

fs/btrfs/super.c

1921

fs_info->fs_devices = NULL;

fs/btrfs/super.c

1934

ASSERT(fc->s_fs_info == fs_info);

fs/btrfs/super.c

1938

fs_info->fs_devices = NULL;

fs/btrfs/super.c

1960

fs_info->fs_devices = NULL;

fs/btrfs/super.c

1970

set_device_specific_options(fs_info);

fs/btrfs/super.c

1981

btrfs_clear_oneshot_options(fs_info);

fs/btrfs/super.c

2072

struct btrfs_fs_info *fs_info = NULL;

fs/btrfs/super.c

2087

fs_info = kvzalloc_obj(struct btrfs_fs_info);

fs/btrfs/super.c

2088

if (!fs_info)

fs/btrfs/super.c

2091

fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL);

fs/btrfs/super.c

2092

fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL);

fs/btrfs/super.c

2093

if (!fs_info->super_copy || !fs_info->super_for_commit) {

fs/btrfs/super.c

2098

kfree(fs_info->super_copy);

fs/btrfs/super.c

2099

kfree(fs_info->super_for_commit);

fs/btrfs/super.c

2100

kvfree(fs_info);

fs/btrfs/super.c

2103

btrfs_init_fs_info(fs_info);

fs/btrfs/super.c

2107

btrfs_free_fs_info(fs_info);

fs/btrfs/super.c

2115

dup_fc->s_fs_info = fs_info;

fs/btrfs/super.c

2156

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2158

btrfs_free_fs_info(fs_info);

fs/btrfs/super.c

2164

struct btrfs_fs_info *fs_info = fc->s_fs_info;

fs/btrfs/super.c

2166

if (fs_info)

fs/btrfs/super.c

2167

btrfs_free_fs_info(fs_info);

fs/btrfs/super.c

2322

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2324

set_bit(BTRFS_FS_FROZEN, &fs_info->flags);

fs/btrfs/super.c

2331

return btrfs_commit_current_transaction(fs_info->tree_root);

fs/btrfs/super.c

2336

struct btrfs_fs_info *fs_info = dev->fs_info;

fs/btrfs/super.c

2343

ASSERT(test_bit(BTRFS_FS_FROZEN, &fs_info->flags));

fs/btrfs/super.c

2356

if (unlikely(csum_type != btrfs_super_csum_type(fs_info->super_copy))) {

fs/btrfs/super.c

2357

btrfs_err(fs_info, "csum type changed, has %u expect %u",

fs/btrfs/super.c

2358

csum_type, btrfs_super_csum_type(fs_info->super_copy));

fs/btrfs/super.c

2363

if (unlikely(btrfs_check_super_csum(fs_info, sb))) {

fs/btrfs/super.c

2364

btrfs_err(fs_info, "csum for on-disk super block no longer matches");

fs/btrfs/super.c

2370

ret = btrfs_validate_super(fs_info, sb, 0);

fs/btrfs/super.c

2374

last_trans = btrfs_get_last_trans_committed(fs_info);

fs/btrfs/super.c

2376

btrfs_err(fs_info, "transid mismatch, has %llu expect %llu",

fs/btrfs/super.c

2388

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2400

list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) {

fs/btrfs/super.c

2403

btrfs_handle_fs_error(fs_info, ret,

fs/btrfs/super.c

2409

clear_bit(BTRFS_FS_FROZEN, &fs_info->flags);

fs/btrfs/super.c

2421

struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);

fs/btrfs/super.c

2429

seq_escape(m, btrfs_dev_name(fs_info->fs_devices->latest_dev), " \t\n\\");

fs/btrfs/super.c

2437

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2438

const s64 nr = percpu_counter_read_positive(&fs_info->evictable_extent_maps);

fs/btrfs/super.c

2449

trace_btrfs_extent_map_shrinker_count(fs_info, nr);

fs/btrfs/super.c

2457

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2459

btrfs_free_extent_maps(fs_info, nr_to_scan);

fs/btrfs/super.c

2467

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2472

mutex_lock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/super.c

2473

device = btrfs_find_device(fs_info->fs_devices, &lookup_args);

fs/btrfs/super.c

2475

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/super.c

2477

btrfs_warn(fs_info, "unable to find btrfs device for block device '%pg'", bdev);

fs/btrfs/super.c

2486

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/super.c

2487

btrfs_warn(fs_info, "btrfs device id %llu is already missing", device->devid);

fs/btrfs/super.c

2497

can_rw = btrfs_check_rw_degradable(fs_info, device);

fs/btrfs/super.c

2498

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/super.c

2504

btrfs_crit(fs_info,

fs/btrfs/super.c

2509

btrfs_warn(fs_info,

fs/btrfs/super.c

2512

btrfs_set_opt(fs_info->mount_opt, DEGRADED);

fs/btrfs/super.c

2518

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2520

btrfs_force_shutdown(fs_info);

fs/btrfs/super.c

2525

struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);

fs/btrfs/super.c

2527

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/super.c

2528

btrfs_show_zoned_stats(fs_info, seq);

fs/btrfs/super.c

669

static void btrfs_clear_oneshot_options(struct btrfs_fs_info *fs_info)

fs/btrfs/super.c

671

btrfs_clear_opt(fs_info->mount_opt, USEBACKUPROOT);

fs/btrfs/super.c

672

btrfs_clear_opt(fs_info->mount_opt, CLEAR_CACHE);

fs/btrfs/super.c

673

btrfs_clear_opt(fs_info->mount_opt, NOSPACECACHE);

fs/btrfs/super.c

676

static bool check_ro_option(const struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

681

btrfs_err(fs_info, "%s must be used with ro mount option",

fs/btrfs/super.c

73

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

739

void btrfs_set_free_space_cache_settings(struct btrfs_fs_info *fs_info)

fs/btrfs/super.c

741

if (fs_info->sectorsize != PAGE_SIZE && btrfs_test_opt(fs_info, SPACE_CACHE)) {

fs/btrfs/super.c

742

btrfs_info(fs_info,

fs/btrfs/super.c

744

fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/super.c

745

btrfs_clear_opt(fs_info->mount_opt, SPACE_CACHE);

fs/btrfs/super.c

746

btrfs_set_opt(fs_info->mount_opt, FREE_SPACE_TREE);

fs/btrfs/super.c

75

btrfs_info(fs_info, "last unmount of filesystem %pU", fs_info->fs_devices->fsid);

fs/btrfs/super.c

753

if (btrfs_test_opt(fs_info, FREE_SPACE_TREE))

fs/btrfs/super.c

756

if (btrfs_is_zoned(fs_info) &&

fs/btrfs/super.c

757

btrfs_free_space_cache_v1_active(fs_info)) {

fs/btrfs/super.c

758

btrfs_info(fs_info, "zoned: clearing existing space cache");

fs/btrfs/super.c

759

btrfs_set_super_cache_generation(fs_info->super_copy, 0);

fs/btrfs/super.c

76

close_ctree(fs_info);

fs/btrfs/super.c

763

if (btrfs_test_opt(fs_info, SPACE_CACHE))

fs/btrfs/super.c

766

if (btrfs_test_opt(fs_info, NOSPACECACHE))

fs/btrfs/super.c

773

if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE))

fs/btrfs/super.c

774

btrfs_set_opt(fs_info->mount_opt, FREE_SPACE_TREE);

fs/btrfs/super.c

775

else if (btrfs_free_space_cache_v1_active(fs_info))

fs/btrfs/super.c

776

btrfs_set_opt(fs_info->mount_opt, SPACE_CACHE);

fs/btrfs/super.c

779

static void set_device_specific_options(struct btrfs_fs_info *fs_info)

fs/btrfs/super.c

781

if (!btrfs_test_opt(fs_info, NOSSD) &&

fs/btrfs/super.c

782

!fs_info->fs_devices->rotating)

fs/btrfs/super.c

783

btrfs_set_opt(fs_info->mount_opt, SSD);

fs/btrfs/super.c

794

if (!(btrfs_test_opt(fs_info, DISCARD_SYNC) ||

fs/btrfs/super.c

795

btrfs_test_opt(fs_info, DISCARD_ASYNC) ||

fs/btrfs/super.c

796

btrfs_test_opt(fs_info, NODISCARD)) &&

fs/btrfs/super.c

797

fs_info->fs_devices->discardable &&

fs/btrfs/super.c

798

!btrfs_is_zoned(fs_info))

fs/btrfs/super.c

799

btrfs_set_opt(fs_info->mount_opt, DISCARD_ASYNC);

fs/btrfs/super.c

802

char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

805

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/super.c

861

fs_root = btrfs_get_fs_root(fs_info, subvol_objectid, true);

fs/btrfs/super.c

920

static int get_default_subvol_objectid(struct btrfs_fs_info *fs_info, u64 *objectid)

fs/btrfs/super.c

922

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/super.c

938

dir_id = btrfs_super_root_dir(fs_info->super_copy);

fs/btrfs/super.c

962

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

979

btrfs_err(fs_info, "super_setup_bdi failed");

fs/btrfs/super.c

985

btrfs_err(fs_info, "open_ctree failed: %d", ret);

fs/btrfs/super.c

989

btrfs_emit_options(fs_info, NULL);

fs/btrfs/super.c

991

inode = btrfs_iget(BTRFS_FIRST_FREE_OBJECTID, fs_info->fs_root);

fs/btrfs/super.c

994

btrfs_handle_fs_error(fs_info, ret, NULL);

fs/btrfs/super.h

17

char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,

fs/btrfs/super.h

19

void btrfs_set_free_space_cache_settings(struct btrfs_fs_info *fs_info);

fs/btrfs/sysfs.c

1075

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1076

char *label = fs_info->super_copy->label;

fs/btrfs/sysfs.c

1079

spin_lock(&fs_info->super_lock);

fs/btrfs/sysfs.c

1081

spin_unlock(&fs_info->super_lock);

fs/btrfs/sysfs.c

1090

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1093

if (!fs_info)

fs/btrfs/sysfs.c

1096

if (sb_rdonly(fs_info->sb))

fs/btrfs/sysfs.c

1108

spin_lock(&fs_info->super_lock);

fs/btrfs/sysfs.c

1109

memset(fs_info->super_copy->label, 0, BTRFS_LABEL_SIZE);

fs/btrfs/sysfs.c

1110

memcpy(fs_info->super_copy->label, buf, p_len);

fs/btrfs/sysfs.c

1111

spin_unlock(&fs_info->super_lock);

fs/btrfs/sysfs.c

1116

set_bit(BTRFS_FS_NEED_TRANS_COMMIT, &fs_info->flags);

fs/btrfs/sysfs.c

1117

wake_up_process(fs_info->transaction_kthread);

fs/btrfs/sysfs.c

1126

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1128

return sysfs_emit(buf, "%u\n", fs_info->nodesize);

fs/btrfs/sysfs.c

1136

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1138

return sysfs_emit(buf, "%u\n", fs_info->sectorsize);

fs/btrfs/sysfs.c

1146

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1148

u64 start_time = fs_info->commit_stats.critical_section_start_time;

fs/btrfs/sysfs.c

1160

fs_info->commit_stats.commit_count,

fs/btrfs/sysfs.c

1162

div_u64(fs_info->commit_stats.last_commit_dur, NSEC_PER_MSEC),

fs/btrfs/sysfs.c

1163

div_u64(fs_info->commit_stats.max_commit_dur, NSEC_PER_MSEC),

fs/btrfs/sysfs.c

1164

div_u64(fs_info->commit_stats.total_commit_dur, NSEC_PER_MSEC));

fs/btrfs/sysfs.c

1171

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1175

if (!fs_info)

fs/btrfs/sysfs.c

1187

WRITE_ONCE(fs_info->commit_stats.max_commit_dur, 0);

fs/btrfs/sysfs.c

1196

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1198

return sysfs_emit(buf, "%u\n", fs_info->sectorsize);

fs/btrfs/sysfs.c

1206

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1209

quota_override = test_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags);

fs/btrfs/sysfs.c

121

static u64 get_features(struct btrfs_fs_info *fs_info,

fs/btrfs/sysfs.c

1217

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1221

if (!fs_info)

fs/btrfs/sysfs.c

1234

set_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags);

fs/btrfs/sysfs.c

1236

clear_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags);

fs/btrfs/sysfs.c

124

struct btrfs_super_block *disk_super = fs_info->super_copy;

fs/btrfs/sysfs.c

1246

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1248

return sysfs_emit(buf, "%pU\n", fs_info->fs_devices->metadata_uuid);

fs/btrfs/sysfs.c

1256

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1257

u16 csum_type = btrfs_super_csum_type(fs_info->super_copy);

fs/btrfs/sysfs.c

1268

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1271

switch (READ_ONCE(fs_info->exclusive_operation)) {

fs/btrfs/sysfs.c

1307

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1309

return sysfs_emit(buf, "%llu\n", btrfs_get_fs_generation(fs_info));

fs/btrfs/sysfs.c

1316

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1318

return sysfs_emit(buf, "%d\n", fs_info->fs_devices->temp_fsid);

fs/btrfs/sysfs.c

133

static void set_features(struct btrfs_fs_info *fs_info,

fs/btrfs/sysfs.c

136

struct btrfs_super_block *disk_super = fs_info->super_copy;

fs/btrfs/sysfs.c

1445

const u32 sectorsize = fs_devices->fs_info->sectorsize;

fs/btrfs/sysfs.c

1450

btrfs_debug(fs_devices->fs_info,

fs/btrfs/sysfs.c

1464

btrfs_info(fs_devices->fs_info, "read policy set to '%s:%lld'",

fs/btrfs/sysfs.c

1491

btrfs_info(fs_devices->fs_info, "read policy set to '%s:%llu'",

fs/btrfs/sysfs.c

1500

btrfs_info(fs_devices->fs_info, "read policy set to '%s'",

fs/btrfs/sysfs.c

1512

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1514

return sysfs_emit(buf, "%d\n", READ_ONCE(fs_info->bg_reclaim_threshold));

fs/btrfs/sysfs.c

1521

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

1537

WRITE_ONCE(fs_info->bg_reclaim_threshold, thresh);

fs/btrfs/sysfs.c

1590

return to_fs_devs(kobj)->fs_info;

fs/btrfs/sysfs.c

1619

static int addrm_unknown_feature_attrs(struct btrfs_fs_info *fs_info, bool add)

fs/btrfs/sysfs.c

1630

u64 features = get_features(fs_info, set);

fs/btrfs/sysfs.c

1647

ret = sysfs_merge_group(&fs_info->fs_devices->fsid_kobj,

fs/btrfs/sysfs.c

1652

sysfs_unmerge_group(&fs_info->fs_devices->fsid_kobj,

fs/btrfs/sysfs.c

1710

void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info)

fs/btrfs/sysfs.c

1712

struct kobject *fsid_kobj = &fs_info->fs_devices->fsid_kobj;

fs/btrfs/sysfs.c

1716

if (fs_info->space_info_kobj) {

fs/btrfs/sysfs.c

1717

sysfs_remove_files(fs_info->space_info_kobj, allocation_attrs);

fs/btrfs/sysfs.c

1718

kobject_del(fs_info->space_info_kobj);

fs/btrfs/sysfs.c

1719

kobject_put(fs_info->space_info_kobj);

fs/btrfs/sysfs.c

1721

if (fs_info->discard_kobj) {

fs/btrfs/sysfs.c

1722

sysfs_remove_files(fs_info->discard_kobj, discard_attrs);

fs/btrfs/sysfs.c

1723

kobject_del(fs_info->discard_kobj);

fs/btrfs/sysfs.c

1724

kobject_put(fs_info->discard_kobj);

fs/btrfs/sysfs.c

1727

if (fs_info->debug_kobj) {

fs/btrfs/sysfs.c

1728

sysfs_remove_files(fs_info->debug_kobj, btrfs_debug_mount_attrs);

fs/btrfs/sysfs.c

1729

kobject_del(fs_info->debug_kobj);

fs/btrfs/sysfs.c

1730

kobject_put(fs_info->debug_kobj);

fs/btrfs/sysfs.c

1733

addrm_unknown_feature_attrs(fs_info, false);

fs/btrfs/sysfs.c

1736

btrfs_sysfs_remove_fs_devices(fs_info->fs_devices);

fs/btrfs/sysfs.c

179

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

181

if (fs_info) {

fs/btrfs/sysfs.c

182

u64 features = get_features(fs_info, fa->feature_set);

fs/btrfs/sysfs.c

1820

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/sysfs.c

1839

btrfs_warn(cache->fs_info,

fs/btrfs/sysfs.c

1874

btrfs_warn(fs_info,

fs/btrfs/sysfs.c

1949

space_info->fs_info->space_info_kobj, "%s",

fs/btrfs/sysfs.c

195

struct btrfs_fs_info *fs_info;

fs/btrfs/sysfs.c

1967

devices_kobj = device->fs_info->fs_devices->devices_kobj;

fs/btrfs/sysfs.c

201

fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

202

if (!fs_info)

fs/btrfs/sysfs.c

205

if (sb_rdonly(fs_info->sb))

fs/btrfs/sysfs.c

2145

devices_kobj = device->fs_info->fs_devices->devices_kobj;

fs/btrfs/sysfs.c

2146

devinfo_kobj = device->fs_info->fs_devices->devinfo_kobj;

fs/btrfs/sysfs.c

2157

btrfs_warn(device->fs_info,

fs/btrfs/sysfs.c

2169

btrfs_warn(device->fs_info,

fs/btrfs/sysfs.c

2228

btrfs_warn(fs_devices->fs_info,

fs/btrfs/sysfs.c

223

features = get_features(fs_info, fa->feature_set);

fs/btrfs/sysfs.c

2239

btrfs_warn(device->fs_devices->fs_info,

fs/btrfs/sysfs.c

2269

btrfs_err(fs_devs->fs_info,

fs/btrfs/sysfs.c

2278

btrfs_err(fs_devs->fs_info,

fs/btrfs/sysfs.c

2287

int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info)

fs/btrfs/sysfs.c

2290

struct btrfs_fs_devices *fs_devs = fs_info->fs_devices;

fs/btrfs/sysfs.c

2308

fs_info->debug_kobj = kobject_create_and_add("debug", fsid_kobj);

fs/btrfs/sysfs.c

2309

if (!fs_info->debug_kobj) {

fs/btrfs/sysfs.c

2314

ret = sysfs_create_files(fs_info->debug_kobj, btrfs_debug_mount_attrs);

fs/btrfs/sysfs.c

232

btrfs_info(fs_info,

fs/btrfs/sysfs.c

2320

fs_info->discard_kobj = kobject_create_and_add("discard", fsid_kobj);

fs/btrfs/sysfs.c

2321

if (!fs_info->discard_kobj) {

fs/btrfs/sysfs.c

2326

ret = sysfs_create_files(fs_info->discard_kobj, discard_attrs);

fs/btrfs/sysfs.c

2330

ret = addrm_unknown_feature_attrs(fs_info, true);

fs/btrfs/sysfs.c

2334

ret = sysfs_create_link(fsid_kobj, &fs_info->sb->s_bdi->dev->kobj, "bdi");

fs/btrfs/sysfs.c

2338

fs_info->space_info_kobj = kobject_create_and_add("allocation",

fs/btrfs/sysfs.c

2340

if (!fs_info->space_info_kobj) {

fs/btrfs/sysfs.c

2345

ret = sysfs_create_files(fs_info->space_info_kobj, allocation_attrs);

fs/btrfs/sysfs.c

2351

btrfs_sysfs_remove_mounted(fs_info);

fs/btrfs/sysfs.c

2359

struct btrfs_fs_info *fs_info = to_fs_info(qgroups_kobj->parent);

fs/btrfs/sysfs.c

2362

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/sysfs.c

2363

enabled = fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON;

fs/btrfs/sysfs.c

2364

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/sysfs.c

2374

struct btrfs_fs_info *fs_info = to_fs_info(qgroups_kobj->parent);

fs/btrfs/sysfs.c

2377

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/sysfs.c

2378

ASSERT(btrfs_qgroup_enabled(fs_info));

fs/btrfs/sysfs.c

2379

switch (btrfs_qgroup_mode(fs_info)) {

fs/btrfs/sysfs.c

238

btrfs_info(fs_info, "%s %s feature flag",

fs/btrfs/sysfs.c

2387

btrfs_warn(fs_info, "unexpected qgroup mode %d\n",

fs/btrfs/sysfs.c

2388

btrfs_qgroup_mode(fs_info));

fs/btrfs/sysfs.c

2391

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/sysfs.c

2401

struct btrfs_fs_info *fs_info = to_fs_info(qgroups_kobj->parent);

fs/btrfs/sysfs.c

2404

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/sysfs.c

2405

inconsistent = (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT);

fs/btrfs/sysfs.c

2406

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/sysfs.c

241

spin_lock(&fs_info->super_lock);

fs/btrfs/sysfs.c

2416

struct btrfs_fs_info *fs_info = to_fs_info(qgroups_kobj->parent);

fs/btrfs/sysfs.c

2419

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/sysfs.c

242

features = get_features(fs_info, fa->feature_set);

fs/btrfs/sysfs.c

2420

result = fs_info->qgroup_drop_subtree_thres;

fs/btrfs/sysfs.c

2421

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/sysfs.c

2430

struct btrfs_fs_info *fs_info = to_fs_info(qgroups_kobj->parent);

fs/btrfs/sysfs.c

2441

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/sysfs.c

2442

fs_info->qgroup_drop_subtree_thres = new_thres;

fs/btrfs/sysfs.c

2443

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/sysfs.c

247

set_features(fs_info, fa->feature_set, features);

fs/btrfs/sysfs.c

248

spin_unlock(&fs_info->super_lock);

fs/btrfs/sysfs.c

2485

struct btrfs_fs_info *fs_info = qgroup_kobj_to_fs_info(qgroup_kobj); \

fs/btrfs/sysfs.c

2488

return btrfs_show_u64(&qgroup->_member, &fs_info->qgroup_lock, buf); \

fs/btrfs/sysfs.c

2497

struct btrfs_fs_info *fs_info = qgroup_kobj_to_fs_info(qgroup_kobj); \

fs/btrfs/sysfs.c

2501

&fs_info->qgroup_lock, buf); \

fs/btrfs/sysfs.c

253

set_bit(BTRFS_FS_NEED_TRANS_COMMIT, &fs_info->flags);

fs/btrfs/sysfs.c

254

wake_up_process(fs_info->transaction_kthread);

fs/btrfs/sysfs.c

2545

int btrfs_sysfs_add_one_qgroup(struct btrfs_fs_info *fs_info,

fs/btrfs/sysfs.c

2548

struct kobject *qgroups_kobj = fs_info->qgroups_kobj;

fs/btrfs/sysfs.c

2551

if (btrfs_is_testing(fs_info))

fs/btrfs/sysfs.c

2567

void btrfs_sysfs_del_qgroups(struct btrfs_fs_info *fs_info)

fs/btrfs/sysfs.c

2572

if (btrfs_is_testing(fs_info))

fs/btrfs/sysfs.c

2576

&fs_info->qgroup_tree, node)

fs/btrfs/sysfs.c

2577

btrfs_sysfs_del_one_qgroup(fs_info, qgroup);

fs/btrfs/sysfs.c

2578

if (fs_info->qgroups_kobj) {

fs/btrfs/sysfs.c

2579

kobject_del(fs_info->qgroups_kobj);

fs/btrfs/sysfs.c

2580

kobject_put(fs_info->qgroups_kobj);

fs/btrfs/sysfs.c

2581

fs_info->qgroups_kobj = NULL;

fs/btrfs/sysfs.c

2586

int btrfs_sysfs_add_qgroups(struct btrfs_fs_info *fs_info)

fs/btrfs/sysfs.c

2588

struct kobject *fsid_kobj = &fs_info->fs_devices->fsid_kobj;

fs/btrfs/sysfs.c

2593

if (btrfs_is_testing(fs_info))

fs/btrfs/sysfs.c

2597

if (fs_info->qgroups_kobj)

fs/btrfs/sysfs.c

2600

fs_info->qgroups_kobj = kzalloc_obj(struct kobject);

fs/btrfs/sysfs.c

2601

if (!fs_info->qgroups_kobj)

fs/btrfs/sysfs.c

2604

ret = kobject_init_and_add(fs_info->qgroups_kobj, &qgroups_ktype,

fs/btrfs/sysfs.c

2610

&fs_info->qgroup_tree, node) {

fs/btrfs/sysfs.c

2611

ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);

fs/btrfs/sysfs.c

2618

btrfs_sysfs_del_qgroups(fs_info);

fs/btrfs/sysfs.c

262

struct btrfs_fs_info *fs_info = to_fs_info(kobj);

fs/btrfs/sysfs.c

2622

void btrfs_sysfs_del_one_qgroup(struct btrfs_fs_info *fs_info,

fs/btrfs/sysfs.c

2625

if (btrfs_is_testing(fs_info))

fs/btrfs/sysfs.c

2638

void btrfs_sysfs_feature_update(struct btrfs_fs_info *fs_info)

fs/btrfs/sysfs.c

2643

if (!fs_info)

fs/btrfs/sysfs.c

2646

fsid_kobj = &fs_info->fs_devices->fsid_kobj;

fs/btrfs/sysfs.c

265

if (fs_info) {

fs/btrfs/sysfs.c

2652

btrfs_warn(fs_info,

fs/btrfs/sysfs.c

2654

fs_info->fs_devices->fsid, ret);

fs/btrfs/sysfs.c

270

features = get_features(fs_info, fa->feature_set);

fs/btrfs/sysfs.c

475

struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);

fs/btrfs/sysfs.c

478

atomic64_read(&fs_info->discard_ctl.discardable_bytes));

fs/btrfs/sysfs.c

486

struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);

fs/btrfs/sysfs.c

489

atomic_read(&fs_info->discard_ctl.discardable_extents));

fs/btrfs/sysfs.c

497

struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);

fs/btrfs/sysfs.c

500

fs_info->discard_ctl.discard_bitmap_bytes);

fs/btrfs/sysfs.c

508

struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);

fs/btrfs/sysfs.c

511

atomic64_read(&fs_info->discard_ctl.discard_bytes_saved));

fs/btrfs/sysfs.c

519

struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);

fs/btrfs/sysfs.c

522

fs_info->discard_ctl.discard_extent_bytes);

fs/btrfs/sysfs.c

530

struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);

fs/btrfs/sysfs.c

533

READ_ONCE(fs_info->discard_ctl.iops_limit));

fs/btrfs/sysfs.c

540

struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);

fs/btrfs/sysfs.c

541

struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl;

fs/btrfs/sysfs.c

561

struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);

fs/btrfs/sysfs.c

564

READ_ONCE(fs_info->discard_ctl.kbps_limit));

fs/btrfs/sysfs.c

571

struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);

fs/btrfs/sysfs.c

572

struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl;

fs/btrfs/sysfs.c

591

struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);

fs/btrfs/sysfs.c

594

READ_ONCE(fs_info->discard_ctl.max_discard_size));

fs/btrfs/sysfs.c

601

struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);

fs/btrfs/sysfs.c

602

struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl;

fs/btrfs/sysfs.c

675

struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent);

fs/btrfs/sysfs.c

676

struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;

fs/btrfs/sysfs.c

684

struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent);

fs/btrfs/sysfs.c

685

struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;

fs/btrfs/sysfs.c

771

struct btrfs_fs_info *fs_info = to_fs_info(get_btrfs_kobj(kobj));

fs/btrfs/sysfs.c

778

if (!fs_info->fs_devices)

fs/btrfs/sysfs.c

781

if (btrfs_is_zoned(fs_info))

fs/btrfs/sysfs.c

797

val = min(mult_perc(fs_info->fs_devices->total_rw_bytes, 10), val);

fs/btrfs/sysfs.c

859

struct btrfs_fs_info *fs_info = to_fs_info(get_btrfs_kobj(kobj));

fs/btrfs/sysfs.c

867

if (sb_rdonly(fs_info->sb))

fs/btrfs/sysfs.c

881

trans = btrfs_start_transaction(fs_info->tree_root, 0);

fs/btrfs/sysfs.h

32

void btrfs_sysfs_feature_update(struct btrfs_fs_info *fs_info);

fs/btrfs/sysfs.h

37

int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info);

fs/btrfs/sysfs.h

38

void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info);

fs/btrfs/sysfs.h

44

int btrfs_sysfs_add_one_qgroup(struct btrfs_fs_info *fs_info,

fs/btrfs/sysfs.h

46

void btrfs_sysfs_del_qgroups(struct btrfs_fs_info *fs_info);

fs/btrfs/sysfs.h

47

int btrfs_sysfs_add_qgroups(struct btrfs_fs_info *fs_info);

fs/btrfs/sysfs.h

48

void btrfs_sysfs_del_one_qgroup(struct btrfs_fs_info *fs_info,

fs/btrfs/tests/btrfs-tests.c

105

btrfs_extent_io_tree_init(fs_info, &dev->alloc_state, 0);

fs/btrfs/tests/btrfs-tests.c

107

list_add(&dev->dev_list, &fs_info->fs_devices->devices);

fs/btrfs/tests/btrfs-tests.c

120

struct btrfs_fs_info *fs_info = kzalloc_obj(struct btrfs_fs_info);

fs/btrfs/tests/btrfs-tests.c

122

if (!fs_info)

fs/btrfs/tests/btrfs-tests.c

123

return fs_info;

fs/btrfs/tests/btrfs-tests.c

124

fs_info->fs_devices = kzalloc_obj(struct btrfs_fs_devices);

fs/btrfs/tests/btrfs-tests.c

125

if (!fs_info->fs_devices) {

fs/btrfs/tests/btrfs-tests.c

126

kfree(fs_info);

fs/btrfs/tests/btrfs-tests.c

129

INIT_LIST_HEAD(&fs_info->fs_devices->devices);

fs/btrfs/tests/btrfs-tests.c

131

fs_info->super_copy = kzalloc_obj(struct btrfs_super_block);

fs/btrfs/tests/btrfs-tests.c

132

if (!fs_info->super_copy) {

fs/btrfs/tests/btrfs-tests.c

133

kfree(fs_info->fs_devices);

fs/btrfs/tests/btrfs-tests.c

134

kfree(fs_info);

fs/btrfs/tests/btrfs-tests.c

138

btrfs_init_fs_info(fs_info);

fs/btrfs/tests/btrfs-tests.c

140

fs_info->nodesize = nodesize;

fs/btrfs/tests/btrfs-tests.c

141

fs_info->sectorsize = sectorsize;

fs/btrfs/tests/btrfs-tests.c

142

fs_info->sectorsize_bits = ilog2(sectorsize);

fs/btrfs/tests/btrfs-tests.c

145

fs_info->csum_size = 4;

fs/btrfs/tests/btrfs-tests.c

146

fs_info->csums_per_leaf = BTRFS_MAX_ITEM_SIZE(fs_info) /

fs/btrfs/tests/btrfs-tests.c

147

fs_info->csum_size;

fs/btrfs/tests/btrfs-tests.c

148

fs_info->use_bitmap = btrfs_use_bitmap;

fs/btrfs/tests/btrfs-tests.c

149

set_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);

fs/btrfs/tests/btrfs-tests.c

151

test_mnt->mnt_sb->s_fs_info = fs_info;

fs/btrfs/tests/btrfs-tests.c

153

return fs_info;

fs/btrfs/tests/btrfs-tests.c

156

void btrfs_free_dummy_fs_info(struct btrfs_fs_info *fs_info)

fs/btrfs/tests/btrfs-tests.c

162

if (!fs_info)

fs/btrfs/tests/btrfs-tests.c

165

if (WARN_ON(!btrfs_is_testing(fs_info)))

fs/btrfs/tests/btrfs-tests.c

170

xa_lock_irq(&fs_info->buffer_tree);

fs/btrfs/tests/btrfs-tests.c

171

xa_for_each(&fs_info->buffer_tree, index, eb) {

fs/btrfs/tests/btrfs-tests.c

172

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/tests/btrfs-tests.c

174

xa_lock_irq(&fs_info->buffer_tree);

fs/btrfs/tests/btrfs-tests.c

176

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/tests/btrfs-tests.c

178

btrfs_mapping_tree_free(fs_info);

fs/btrfs/tests/btrfs-tests.c

179

list_for_each_entry_safe(dev, tmp, &fs_info->fs_devices->devices,

fs/btrfs/tests/btrfs-tests.c

183

btrfs_free_qgroup_config(fs_info);

fs/btrfs/tests/btrfs-tests.c

184

btrfs_free_fs_roots(fs_info);

fs/btrfs/tests/btrfs-tests.c

185

kfree(fs_info->super_copy);

fs/btrfs/tests/btrfs-tests.c

186

btrfs_check_leaked_roots(fs_info);

fs/btrfs/tests/btrfs-tests.c

187

btrfs_extent_buffer_leak_debug_check(fs_info);

fs/btrfs/tests/btrfs-tests.c

188

kfree(fs_info->fs_devices);

fs/btrfs/tests/btrfs-tests.c

189

kfree(fs_info);

fs/btrfs/tests/btrfs-tests.c

204

btrfs_alloc_dummy_block_group(struct btrfs_fs_info *fs_info,

fs/btrfs/tests/btrfs-tests.c

220

cache->full_stripe_len = fs_info->sectorsize;

fs/btrfs/tests/btrfs-tests.c

221

cache->fs_info = fs_info;

fs/btrfs/tests/btrfs-tests.c

241

void btrfs_init_dummy_transaction(struct btrfs_transaction *trans, struct btrfs_fs_info *fs_info)

fs/btrfs/tests/btrfs-tests.c

244

trans->fs_info = fs_info;

fs/btrfs/tests/btrfs-tests.c

251

struct btrfs_fs_info *fs_info)

fs/btrfs/tests/btrfs-tests.c

256

trans->fs_info = fs_info;

fs/btrfs/tests/btrfs-tests.c

97

struct btrfs_device *btrfs_alloc_dummy_device(struct btrfs_fs_info *fs_info)

fs/btrfs/tests/btrfs-tests.h

53

void btrfs_free_dummy_fs_info(struct btrfs_fs_info *fs_info);

fs/btrfs/tests/btrfs-tests.h

58

btrfs_alloc_dummy_block_group(struct btrfs_fs_info *fs_info, unsigned long length);

fs/btrfs/tests/btrfs-tests.h

63

struct btrfs_fs_info *fs_info);

fs/btrfs/tests/btrfs-tests.h

64

void btrfs_init_dummy_transaction(struct btrfs_transaction *trans, struct btrfs_fs_info *fs_info);

fs/btrfs/tests/btrfs-tests.h

65

struct btrfs_device *btrfs_alloc_dummy_device(struct btrfs_fs_info *fs_info);

fs/btrfs/tests/chunk-allocation-tests.c

244

struct btrfs_fs_info *fs_info;

fs/btrfs/tests/chunk-allocation-tests.c

250

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/chunk-allocation-tests.c

251

if (!fs_info) {

fs/btrfs/tests/chunk-allocation-tests.c

256

device = btrfs_alloc_dummy_device(fs_info);

fs/btrfs/tests/chunk-allocation-tests.c

262

device->fs_info = fs_info;

fs/btrfs/tests/chunk-allocation-tests.c

281

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/tests/chunk-allocation-tests.c

284

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/tests/chunk-allocation-tests.c

310

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/chunk-allocation-tests.c

389

struct btrfs_fs_info *fs_info;

fs/btrfs/tests/chunk-allocation-tests.c

395

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/chunk-allocation-tests.c

396

if (!fs_info) {

fs/btrfs/tests/chunk-allocation-tests.c

401

device = btrfs_alloc_dummy_device(fs_info);

fs/btrfs/tests/chunk-allocation-tests.c

408

device->fs_info = fs_info;

fs/btrfs/tests/chunk-allocation-tests.c

423

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/tests/chunk-allocation-tests.c

427

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/tests/chunk-allocation-tests.c

457

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/delayed-refs-tests.c

1014

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/delayed-refs-tests.c

172

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/delayed-refs-tests.c

181

.num_bytes = fs_info->nodesize,

fs/btrfs/tests/delayed-refs-tests.c

201

head = btrfs_select_ref_head(fs_info, delayed_refs);

fs/btrfs/tests/delayed-refs-tests.c

238

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/delayed-refs-tests.c

241

.num_bytes = fs_info->nodesize,

fs/btrfs/tests/delayed-refs-tests.c

247

.num_bytes = fs_info->nodesize,

fs/btrfs/tests/delayed-refs-tests.c

340

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/delayed-refs-tests.c

349

.num_bytes = fs_info->nodesize,

fs/btrfs/tests/delayed-refs-tests.c

353

.num_bytes = fs_info->nodesize,

fs/btrfs/tests/delayed-refs-tests.c

359

.num_bytes = fs_info->nodesize,

fs/btrfs/tests/delayed-refs-tests.c

402

head = btrfs_select_ref_head(fs_info, &trans->transaction->delayed_refs);

fs/btrfs/tests/delayed-refs-tests.c

452

head = btrfs_select_ref_head(fs_info, &trans->transaction->delayed_refs);

fs/btrfs/tests/delayed-refs-tests.c

46

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/delayed-refs-tests.c

515

head = btrfs_select_ref_head(fs_info, &trans->transaction->delayed_refs);

fs/btrfs/tests/delayed-refs-tests.c

52

btrfs_delete_ref_head(fs_info, delayed_refs, head);

fs/btrfs/tests/delayed-refs-tests.c

584

head = btrfs_select_ref_head(fs_info, &trans->transaction->delayed_refs);

fs/btrfs/tests/delayed-refs-tests.c

654

head = btrfs_select_ref_head(fs_info, &trans->transaction->delayed_refs);

fs/btrfs/tests/delayed-refs-tests.c

709

ref.parent = FAKE_PARENT + (i * fs_info->nodesize);

fs/btrfs/tests/delayed-refs-tests.c

727

ref.parent = FAKE_PARENT + (i * fs_info->nodesize);

fs/btrfs/tests/delayed-refs-tests.c

739

head = btrfs_select_ref_head(fs_info, &trans->transaction->delayed_refs);

fs/btrfs/tests/delayed-refs-tests.c

781

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/delayed-refs-tests.c

790

.num_bytes = fs_info->nodesize,

fs/btrfs/tests/delayed-refs-tests.c

794

.num_bytes = fs_info->nodesize,

fs/btrfs/tests/delayed-refs-tests.c

800

.num_bytes = fs_info->nodesize,

fs/btrfs/tests/delayed-refs-tests.c

830

head = btrfs_select_ref_head(fs_info, delayed_refs);

fs/btrfs/tests/delayed-refs-tests.c

917

head = btrfs_select_ref_head(fs_info, delayed_refs);

fs/btrfs/tests/delayed-refs-tests.c

978

struct btrfs_fs_info *fs_info;

fs/btrfs/tests/delayed-refs-tests.c

983

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/delayed-refs-tests.c

984

if (!fs_info) {

fs/btrfs/tests/delayed-refs-tests.c

994

btrfs_init_dummy_trans(&trans, fs_info);

fs/btrfs/tests/delayed-refs-tests.c

995

btrfs_init_dummy_transaction(transaction, fs_info);

fs/btrfs/tests/extent-buffer-tests.c

15

struct btrfs_fs_info *fs_info;

fs/btrfs/tests/extent-buffer-tests.c

215

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/extent-buffer-tests.c

31

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/extent-buffer-tests.c

32

if (!fs_info) {

fs/btrfs/tests/extent-buffer-tests.c

37

root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/extent-buffer-tests.c

51

eb = alloc_dummy_extent_buffer(fs_info, nodesize);

fs/btrfs/tests/extent-io-tests.c

111

struct btrfs_fs_info *fs_info;

fs/btrfs/tests/extent-io-tests.c

126

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/extent-io-tests.c

127

if (!fs_info) {

fs/btrfs/tests/extent-io-tests.c

132

root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/extent-io-tests.c

337

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/extent-io-tests.c

507

struct btrfs_fs_info *fs_info;

fs/btrfs/tests/extent-io-tests.c

514

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/extent-io-tests.c

515

if (!fs_info) {

fs/btrfs/tests/extent-io-tests.c

527

eb = alloc_dummy_extent_buffer(fs_info, 0);

fs/btrfs/tests/extent-io-tests.c

544

eb = alloc_dummy_extent_buffer(fs_info, sectorsize);

fs/btrfs/tests/extent-io-tests.c

554

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/extent-io-tests.c

711

struct btrfs_fs_info *fs_info;

fs/btrfs/tests/extent-io-tests.c

718

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/extent-io-tests.c

719

if (!fs_info) {

fs/btrfs/tests/extent-io-tests.c

731

eb = alloc_dummy_extent_buffer(fs_info, SZ_1M);

fs/btrfs/tests/extent-io-tests.c

805

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/extent-map-tests.c

1015

static int test_rmap_block(struct btrfs_fs_info *fs_info,

fs/btrfs/tests/extent-map-tests.c

1037

struct btrfs_device *dev = btrfs_alloc_dummy_device(fs_info);

fs/btrfs/tests/extent-map-tests.c

1048

ret = btrfs_add_chunk_map(fs_info, map);

fs/btrfs/tests/extent-map-tests.c

1055

ret = btrfs_rmap_block(fs_info, map->start, btrfs_sb_offset(1),

fs/btrfs/tests/extent-map-tests.c

1087

btrfs_remove_chunk_map(fs_info, map);

fs/btrfs/tests/extent-map-tests.c

1093

struct btrfs_fs_info *fs_info = NULL;

fs/btrfs/tests/extent-map-tests.c

1141

fs_info = btrfs_alloc_dummy_fs_info(SZ_4K, SZ_4K);

fs/btrfs/tests/extent-map-tests.c

1142

if (!fs_info) {

fs/btrfs/tests/extent-map-tests.c

1154

root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/extent-map-tests.c

1164

ret = test_case_1(fs_info, BTRFS_I(inode));

fs/btrfs/tests/extent-map-tests.c

1167

ret = test_case_2(fs_info, BTRFS_I(inode));

fs/btrfs/tests/extent-map-tests.c

1170

ret = test_case_3(fs_info, BTRFS_I(inode));

fs/btrfs/tests/extent-map-tests.c

1173

ret = test_case_4(fs_info, BTRFS_I(inode));

fs/btrfs/tests/extent-map-tests.c

1176

ret = test_case_5(fs_info, BTRFS_I(inode));

fs/btrfs/tests/extent-map-tests.c

1179

ret = test_case_6(fs_info, BTRFS_I(inode));

fs/btrfs/tests/extent-map-tests.c

1182

ret = test_case_7(fs_info, BTRFS_I(inode));

fs/btrfs/tests/extent-map-tests.c

1185

ret = test_case_8(fs_info, BTRFS_I(inode));

fs/btrfs/tests/extent-map-tests.c

1191

ret = test_rmap_block(fs_info, &rmap_tests[i]);

fs/btrfs/tests/extent-map-tests.c

1199

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/extent-map-tests.c

163

static int test_case_2(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)

fs/btrfs/tests/extent-map-tests.c

257

static int __test_case_3(struct btrfs_fs_info *fs_info,

fs/btrfs/tests/extent-map-tests.c

351

static int test_case_3(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)

fs/btrfs/tests/extent-map-tests.c

355

ret = __test_case_3(fs_info, inode, 0);

fs/btrfs/tests/extent-map-tests.c

358

ret = __test_case_3(fs_info, inode, SZ_8K);

fs/btrfs/tests/extent-map-tests.c

361

ret = __test_case_3(fs_info, inode, (12 * SZ_1K));

fs/btrfs/tests/extent-map-tests.c

366

static int __test_case_4(struct btrfs_fs_info *fs_info,

fs/btrfs/tests/extent-map-tests.c

485

static int test_case_4(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)

fs/btrfs/tests/extent-map-tests.c

489

ret = __test_case_4(fs_info, inode, 0);

fs/btrfs/tests/extent-map-tests.c

492

ret = __test_case_4(fs_info, inode, SZ_4K);

fs/btrfs/tests/extent-map-tests.c

62

static int test_case_1(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)

fs/btrfs/tests/extent-map-tests.c

623

static int test_case_5(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)

fs/btrfs/tests/extent-map-tests.c

710

static int test_case_6(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)

fs/btrfs/tests/extent-map-tests.c

770

static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)

fs/btrfs/tests/extent-map-tests.c

912

static int test_case_8(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)

fs/btrfs/tests/free-space-tests.c

1003

struct btrfs_fs_info *fs_info;

fs/btrfs/tests/free-space-tests.c

1009

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/free-space-tests.c

1010

if (!fs_info) {

fs/btrfs/tests/free-space-tests.c

1020

cache = btrfs_alloc_dummy_block_group(fs_info,

fs/btrfs/tests/free-space-tests.c

1024

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/free-space-tests.c

1028

root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/free-space-tests.c

1057

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/free-space-tests.c

424

orig_use_bitmap = cache->fs_info->use_bitmap;

fs/btrfs/tests/free-space-tests.c

425

cache->fs_info->use_bitmap = test_use_bitmap;

fs/btrfs/tests/free-space-tests.c

819

cache->fs_info->use_bitmap = orig_use_bitmap;

fs/btrfs/tests/free-space-tests.c

891

orig_use_bitmap = cache->fs_info->use_bitmap;

fs/btrfs/tests/free-space-tests.c

892

cache->fs_info->use_bitmap = bytes_index_use_bitmap;

fs/btrfs/tests/free-space-tests.c

996

cache->fs_info->use_bitmap = orig_use_bitmap;

fs/btrfs/tests/free-space-tree-tests.c

108

struct btrfs_fs_info *fs_info,

fs/btrfs/tests/free-space-tree-tests.c

127

ret = __check_free_space_extents(trans, fs_info, cache, path, extents,

fs/btrfs/tests/free-space-tree-tests.c

146

return __check_free_space_extents(trans, fs_info, cache, path, extents,

fs/btrfs/tests/free-space-tree-tests.c

151

struct btrfs_fs_info *fs_info,

fs/btrfs/tests/free-space-tree-tests.c

160

return check_free_space_extents(trans, fs_info, cache, path,

fs/btrfs/tests/free-space-tree-tests.c

165

struct btrfs_fs_info *fs_info,

fs/btrfs/tests/free-space-tree-tests.c

180

return check_free_space_extents(trans, fs_info, cache, path,

fs/btrfs/tests/free-space-tree-tests.c

185

struct btrfs_fs_info *fs_info,

fs/btrfs/tests/free-space-tree-tests.c

202

return check_free_space_extents(trans, fs_info, cache, path,

fs/btrfs/tests/free-space-tree-tests.c

208

struct btrfs_fs_info *fs_info,

fs/btrfs/tests/free-space-tree-tests.c

21

struct btrfs_fs_info *fs_info,

fs/btrfs/tests/free-space-tree-tests.c

226

return check_free_space_extents(trans, fs_info, cache, path,

fs/btrfs/tests/free-space-tree-tests.c

231

struct btrfs_fs_info *fs_info,

fs/btrfs/tests/free-space-tree-tests.c

250

return check_free_space_extents(trans, fs_info, cache, path,

fs/btrfs/tests/free-space-tree-tests.c

255

struct btrfs_fs_info *fs_info,

fs/btrfs/tests/free-space-tree-tests.c

286

return check_free_space_extents(trans, fs_info, cache, path,

fs/btrfs/tests/free-space-tree-tests.c

291

struct btrfs_fs_info *fs_info,

fs/btrfs/tests/free-space-tree-tests.c

323

return check_free_space_extents(trans, fs_info, cache, path,

fs/btrfs/tests/free-space-tree-tests.c

328

struct btrfs_fs_info *fs_info,

fs/btrfs/tests/free-space-tree-tests.c

366

return check_free_space_extents(trans, fs_info, cache, path,

fs/btrfs/tests/free-space-tree-tests.c

371

struct btrfs_fs_info *fs_info,

fs/btrfs/tests/free-space-tree-tests.c

411

return check_free_space_extents(trans, fs_info, cache, path,

fs/btrfs/tests/free-space-tree-tests.c

424

struct btrfs_fs_info *fs_info;

fs/btrfs/tests/free-space-tree-tests.c

431

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/free-space-tree-tests.c

432

if (!fs_info) {

fs/btrfs/tests/free-space-tree-tests.c

438

root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/free-space-tree-tests.c

445

btrfs_set_super_compat_ro_flags(root->fs_info->super_copy,

fs/btrfs/tests/free-space-tree-tests.c

451

root->fs_info->tree_root = root;

fs/btrfs/tests/free-space-tree-tests.c

453

root->node = alloc_test_extent_buffer(root->fs_info, nodesize);

fs/btrfs/tests/free-space-tree-tests.c

463

cache = btrfs_alloc_dummy_block_group(fs_info, 8 * alignment);

fs/btrfs/tests/free-space-tree-tests.c

472

cache->fs_info = root->fs_info;

fs/btrfs/tests/free-space-tree-tests.c

474

btrfs_init_dummy_trans(&trans, root->fs_info);

fs/btrfs/tests/free-space-tree-tests.c

497

ret = test_func(&trans, root->fs_info, cache, path, alignment);

fs/btrfs/tests/free-space-tree-tests.c

518

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/free-space-tree-tests.c

71

offset += fs_info->sectorsize;

fs/btrfs/tests/inode-tests.c

1075

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/inode-tests.c

244

struct btrfs_fs_info *fs_info = NULL;

fs/btrfs/tests/inode-tests.c

261

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/inode-tests.c

262

if (!fs_info) {

fs/btrfs/tests/inode-tests.c

267

root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/inode-tests.c

273

root->node = alloc_dummy_extent_buffer(fs_info, nodesize);

fs/btrfs/tests/inode-tests.c

793

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/inode-tests.c

799

struct btrfs_fs_info *fs_info = NULL;

fs/btrfs/tests/inode-tests.c

813

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/inode-tests.c

814

if (!fs_info) {

fs/btrfs/tests/inode-tests.c

819

root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/inode-tests.c

825

root->node = alloc_dummy_extent_buffer(fs_info, nodesize);

fs/btrfs/tests/inode-tests.c

892

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/inode-tests.c

898

struct btrfs_fs_info *fs_info = NULL;

fs/btrfs/tests/inode-tests.c

911

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/inode-tests.c

912

if (!fs_info) {

fs/btrfs/tests/inode-tests.c

917

root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/qgroup-tests.c

201

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tests/qgroup-tests.c

206

btrfs_init_dummy_trans(&trans, fs_info);

fs/btrfs/tests/qgroup-tests.c

217

ctx.fs_info = fs_info;

fs/btrfs/tests/qgroup-tests.c

259

if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FS_TREE_OBJECTID,

fs/btrfs/tests/qgroup-tests.c

295

if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FS_TREE_OBJECTID, 0, 0)) {

fs/btrfs/tests/qgroup-tests.c

313

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tests/qgroup-tests.c

318

btrfs_init_dummy_trans(&trans, fs_info);

fs/btrfs/tests/qgroup-tests.c

334

ctx.fs_info = fs_info;

fs/btrfs/tests/qgroup-tests.c

367

if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FS_TREE_OBJECTID,

fs/btrfs/tests/qgroup-tests.c

404

if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FS_TREE_OBJECTID,

fs/btrfs/tests/qgroup-tests.c

410

if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FIRST_FREE_OBJECTID,

fs/btrfs/tests/qgroup-tests.c

447

if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FIRST_FREE_OBJECTID,

fs/btrfs/tests/qgroup-tests.c

453

if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FS_TREE_OBJECTID,

fs/btrfs/tests/qgroup-tests.c

464

struct btrfs_fs_info *fs_info = NULL;

fs/btrfs/tests/qgroup-tests.c

469

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/qgroup-tests.c

470

if (!fs_info) {

fs/btrfs/tests/qgroup-tests.c

475

root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/qgroup-tests.c

492

root->fs_info->tree_root = root;

fs/btrfs/tests/qgroup-tests.c

493

root->fs_info->quota_root = root;

fs/btrfs/tests/qgroup-tests.c

494

set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);

fs/btrfs/tests/qgroup-tests.c

500

root->node = alloc_test_extent_buffer(root->fs_info, nodesize);

fs/btrfs/tests/qgroup-tests.c

510

tmp_root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/qgroup-tests.c

518

root->fs_info->fs_root = tmp_root;

fs/btrfs/tests/qgroup-tests.c

519

ret = btrfs_insert_fs_root(root->fs_info, tmp_root);

fs/btrfs/tests/qgroup-tests.c

526

tmp_root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/qgroup-tests.c

534

ret = btrfs_insert_fs_root(root->fs_info, tmp_root);

fs/btrfs/tests/qgroup-tests.c

548

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/raid-stripe-tree-tests.c

1007

bioc = alloc_btrfs_io_context(fs_info, logical, RST_TEST_NUM_DEVICES);

fs/btrfs/tests/raid-stripe-tree-tests.c

1020

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

1036

io_stripe.dev = btrfs_device_by_devid(fs_info->fs_devices, 0);

fs/btrfs/tests/raid-stripe-tree-tests.c

1042

ret = btrfs_get_raid_extent_offset(fs_info, logical, &len, map_type, 0, &io_stripe);

fs/btrfs/tests/raid-stripe-tree-tests.c

1087

struct btrfs_fs_info *fs_info;

fs/btrfs/tests/raid-stripe-tree-tests.c

1091

fs_info = btrfs_alloc_dummy_fs_info(sectorsize, nodesize);

fs/btrfs/tests/raid-stripe-tree-tests.c

1092

if (!fs_info) {

fs/btrfs/tests/raid-stripe-tree-tests.c

1098

root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/raid-stripe-tree-tests.c

1104

btrfs_set_super_incompat_flags(root->fs_info->super_copy,

fs/btrfs/tests/raid-stripe-tree-tests.c

1109

fs_info->stripe_root = root;

fs/btrfs/tests/raid-stripe-tree-tests.c

1110

root->fs_info->tree_root = root;

fs/btrfs/tests/raid-stripe-tree-tests.c

1112

root->node = alloc_test_extent_buffer(root->fs_info, nodesize);

fs/btrfs/tests/raid-stripe-tree-tests.c

112

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

1125

dev = btrfs_alloc_dummy_device(fs_info);

fs/btrfs/tests/raid-stripe-tree-tests.c

1134

btrfs_init_dummy_trans(&trans, root->fs_info);

fs/btrfs/tests/raid-stripe-tree-tests.c

1141

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/raid-stripe-tree-tests.c

141

ret = btrfs_get_raid_extent_offset(fs_info, logical1, &len1, map_type,

fs/btrfs/tests/raid-stripe-tree-tests.c

164

ret = btrfs_get_raid_extent_offset(fs_info, logical2, &len2, map_type,

fs/btrfs/tests/raid-stripe-tree-tests.c

175

ret = btrfs_get_raid_extent_offset(fs_info, logical3, &len3, map_type,

fs/btrfs/tests/raid-stripe-tree-tests.c

218

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/raid-stripe-tree-tests.c

230

bioc = alloc_btrfs_io_context(fs_info, logical1, RST_TEST_NUM_DEVICES);

fs/btrfs/tests/raid-stripe-tree-tests.c

237

io_stripe.dev = btrfs_device_by_devid(fs_info->fs_devices, 0);

fs/btrfs/tests/raid-stripe-tree-tests.c

246

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

267

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

288

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

315

ret = btrfs_get_raid_extent_offset(fs_info, logical1, &len1, map_type,

fs/btrfs/tests/raid-stripe-tree-tests.c

323

ret = btrfs_get_raid_extent_offset(fs_info, logical2, &len2, map_type,

fs/btrfs/tests/raid-stripe-tree-tests.c

331

ret = btrfs_get_raid_extent_offset(fs_info, logical3, &len3, map_type,

fs/btrfs/tests/raid-stripe-tree-tests.c

362

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/raid-stripe-tree-tests.c

375

bioc = alloc_btrfs_io_context(fs_info, logical1, RST_TEST_NUM_DEVICES);

fs/btrfs/tests/raid-stripe-tree-tests.c

382

io_stripe.dev = btrfs_device_by_devid(fs_info->fs_devices, 0);

fs/btrfs/tests/raid-stripe-tree-tests.c

389

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

40

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/raid-stripe-tree-tests.c

405

ret = btrfs_get_raid_extent_offset(fs_info, logical1, &len, map_type, 0,

fs/btrfs/tests/raid-stripe-tree-tests.c

434

ret = btrfs_get_raid_extent_offset(fs_info, logical1, &len1, map_type,

fs/btrfs/tests/raid-stripe-tree-tests.c

456

ret = btrfs_get_raid_extent_offset(fs_info, logical2, &len2, map_type,

fs/btrfs/tests/raid-stripe-tree-tests.c

479

ret = btrfs_get_raid_extent_offset(fs_info, hole_start, &hole_len,

fs/btrfs/tests/raid-stripe-tree-tests.c

505

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/raid-stripe-tree-tests.c

514

bioc = alloc_btrfs_io_context(fs_info, logical1, RST_TEST_NUM_DEVICES);

fs/btrfs/tests/raid-stripe-tree-tests.c

521

io_stripe.dev = btrfs_device_by_devid(fs_info->fs_devices, 0);

fs/btrfs/tests/raid-stripe-tree-tests.c

529

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

54

bioc = alloc_btrfs_io_context(fs_info, logical1, RST_TEST_NUM_DEVICES);

fs/btrfs/tests/raid-stripe-tree-tests.c

550

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

574

ret = btrfs_get_raid_extent_offset(fs_info, logical1, &len, map_type, 0,

fs/btrfs/tests/raid-stripe-tree-tests.c

597

ret = btrfs_get_raid_extent_offset(fs_info, logical2 + SZ_512K, &len,

fs/btrfs/tests/raid-stripe-tree-tests.c

61

io_stripe.dev = btrfs_device_by_devid(fs_info->fs_devices, 0);

fs/btrfs/tests/raid-stripe-tree-tests.c

621

ret = btrfs_get_raid_extent_offset(fs_info, logical1 + SZ_512K, &len,

fs/btrfs/tests/raid-stripe-tree-tests.c

647

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/raid-stripe-tree-tests.c

655

bioc = alloc_btrfs_io_context(fs_info, logical, RST_TEST_NUM_DEVICES);

fs/btrfs/tests/raid-stripe-tree-tests.c

662

io_stripe.dev = btrfs_device_by_devid(fs_info->fs_devices, 0);

fs/btrfs/tests/raid-stripe-tree-tests.c

669

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

685

ret = btrfs_get_raid_extent_offset(fs_info, logical, &len, map_type, 0, &io_stripe);

fs/btrfs/tests/raid-stripe-tree-tests.c

70

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

714

ret = btrfs_get_raid_extent_offset(fs_info, logical + SZ_16K, &len,

fs/btrfs/tests/raid-stripe-tree-tests.c

736

ret = btrfs_get_raid_extent_offset(fs_info, logical, &len, map_type, 0, &io_stripe);

fs/btrfs/tests/raid-stripe-tree-tests.c

756

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/raid-stripe-tree-tests.c

764

bioc = alloc_btrfs_io_context(fs_info, logical, RST_TEST_NUM_DEVICES);

fs/btrfs/tests/raid-stripe-tree-tests.c

771

io_stripe.dev = btrfs_device_by_devid(fs_info->fs_devices, 0);

fs/btrfs/tests/raid-stripe-tree-tests.c

778

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

794

io_stripe.dev = btrfs_device_by_devid(fs_info->fs_devices, 0);

fs/btrfs/tests/raid-stripe-tree-tests.c

800

ret = btrfs_get_raid_extent_offset(fs_info, logical, &len, map_type, 0, &io_stripe);

fs/btrfs/tests/raid-stripe-tree-tests.c

829

ret = btrfs_get_raid_extent_offset(fs_info, logical, &len, map_type, 0, &io_stripe);

fs/btrfs/tests/raid-stripe-tree-tests.c

851

ret = btrfs_get_raid_extent_offset(fs_info, logical + SZ_48K, &len,

fs/btrfs/tests/raid-stripe-tree-tests.c

878

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/raid-stripe-tree-tests.c

886

bioc = alloc_btrfs_io_context(fs_info, logical, RST_TEST_NUM_DEVICES);

fs/btrfs/tests/raid-stripe-tree-tests.c

893

io_stripe.dev = btrfs_device_by_devid(fs_info->fs_devices, 0);

fs/btrfs/tests/raid-stripe-tree-tests.c

900

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

91

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

916

io_stripe.dev = btrfs_device_by_devid(fs_info->fs_devices, 0);

fs/btrfs/tests/raid-stripe-tree-tests.c

922

ret = btrfs_get_raid_extent_offset(fs_info, logical, &len, map_type, 0, &io_stripe);

fs/btrfs/tests/raid-stripe-tree-tests.c

946

stripe->dev = btrfs_device_by_devid(fs_info->fs_devices, i);

fs/btrfs/tests/raid-stripe-tree-tests.c

962

ret = btrfs_get_raid_extent_offset(fs_info, logical, &len, map_type, 0, &io_stripe);

fs/btrfs/tests/raid-stripe-tree-tests.c

999

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/tests/zoned-tests.c

40

static int test_load_zone_info(struct btrfs_fs_info *fs_info,

fs/btrfs/tests/zoned-tests.c

49

bg = btrfs_alloc_dummy_block_group(fs_info, test->bg_length);

fs/btrfs/tests/zoned-tests.c

655

struct btrfs_fs_info *fs_info __free(btrfs_free_dummy_fs_info) = NULL;

fs/btrfs/tests/zoned-tests.c

660

fs_info = btrfs_alloc_dummy_fs_info(PAGE_SIZE, PAGE_SIZE);

fs/btrfs/tests/zoned-tests.c

661

if (!fs_info) {

fs/btrfs/tests/zoned-tests.c

667

ret = test_load_zone_info(fs_info, &load_zone_info_tests[i]);

fs/btrfs/tests/zoned-tests.c

85

btrfs_set_opt(fs_info->mount_opt, DEGRADED);

fs/btrfs/tests/zoned-tests.c

87

btrfs_clear_opt(fs_info->mount_opt, DEGRADED);

fs/btrfs/transaction.c

1005

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

1018

void btrfs_throttle(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

1020

wait_current_trans(fs_info, TRANS_START);

fs/btrfs/transaction.c

1031

if (btrfs_check_space_for_delayed_refs(trans->fs_info))

fs/btrfs/transaction.c

1034

return !!btrfs_block_rsv_check(&trans->fs_info->global_block_rsv, 50);

fs/btrfs/transaction.c

1040

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

1058

ASSERT(trans->block_rsv == &fs_info->trans_block_rsv);

fs/btrfs/transaction.c

1059

trace_btrfs_space_reservation(fs_info, "transaction",

fs/btrfs/transaction.c

1061

btrfs_block_rsv_release(fs_info, trans->block_rsv,

fs/btrfs/transaction.c

1068

trace_btrfs_space_reservation(fs_info, "local_delayed_refs_rsv",

fs/btrfs/transaction.c

1071

btrfs_block_rsv_release(fs_info, &trans->delayed_rsv,

fs/btrfs/transaction.c

1079

struct btrfs_fs_info *info = trans->fs_info;

fs/btrfs/transaction.c

1151

int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info,

fs/btrfs/transaction.c

1155

struct address_space *mapping = fs_info->btree_inode->i_mapping;

fs/btrfs/transaction.c

1187

btrfs_btree_wait_writeback_range(fs_info, start, end);

fs/btrfs/transaction.c

1204

static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info,

fs/btrfs/transaction.c

1227

btrfs_btree_wait_writeback_range(fs_info, start, end);

fs/btrfs/transaction.c

1238

static int btrfs_wait_extents(struct btrfs_fs_info *fs_info,

fs/btrfs/transaction.c

1244

ret = __btrfs_wait_marked_extents(fs_info, dirty_pages);

fs/btrfs/transaction.c

1245

if (test_and_clear_bit(BTRFS_FS_BTREE_ERR, &fs_info->flags))

fs/btrfs/transaction.c

1255

struct btrfs_fs_info *fs_info = log_root->fs_info;

fs/btrfs/transaction.c

1263

ret = __btrfs_wait_marked_extents(fs_info, dirty_pages);

fs/btrfs/transaction.c

1265

test_and_clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags))

fs/btrfs/transaction.c

1269

test_and_clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags))

fs/btrfs/transaction.c

1289

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

1293

ret = btrfs_write_marked_extents(fs_info, dirty_pages, EXTENT_DIRTY);

fs/btrfs/transaction.c

1295

ret2 = btrfs_wait_extents(fs_info, dirty_pages);

fs/btrfs/transaction.c

1322

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

1323

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/transaction.c

1355

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

1368

eb = btrfs_lock_root_node(fs_info->tree_root);

fs/btrfs/transaction.c

1369

ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,

fs/btrfs/transaction.c

1392

while (!list_empty(&fs_info->dirty_cowonly_roots)) {

fs/btrfs/transaction.c

1395

root = list_first_entry(&fs_info->dirty_cowonly_roots,

fs/btrfs/transaction.c

1427

if (!list_empty(&fs_info->dirty_cowonly_roots))

fs/btrfs/transaction.c

1431

fs_info->dev_replace.committed_cursor_left =

fs/btrfs/transaction.c

1432

fs_info->dev_replace.cursor_left_last_write_of_item;

fs/btrfs/transaction.c

1441

void btrfs_maybe_wake_unfinished_drop(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

1448

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

1449

if (!list_empty(&fs_info->dead_roots)) {

fs/btrfs/transaction.c

1450

struct btrfs_root *root = list_first_entry(&fs_info->dead_roots,

fs/btrfs/transaction.c

1454

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

1458

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

1460

btrfs_wake_unfinished_drop(fs_info);

fs/btrfs/transaction.c

1470

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

1472

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

1478

list_add(&root->root_list, &fs_info->dead_roots);

fs/btrfs/transaction.c

1480

list_add_tail(&root->root_list, &fs_info->dead_roots);

fs/btrfs/transaction.c

1482

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

149

btrfs_err(transaction->fs_info,

fs/btrfs/transaction.c

1491

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

1503

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

1505

ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,

fs/btrfs/transaction.c

1529

radix_tree_tag_clear(&fs_info->fs_roots_radix,

fs/btrfs/transaction.c

1533

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

1551

ret2 = btrfs_update_root(trans, fs_info->tree_root,

fs/btrfs/transaction.c

1556

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

1559

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

1576

struct btrfs_fs_info *fs_info = src->fs_info;

fs/btrfs/transaction.c

1583

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/transaction.c

1644

btrfs_err(fs_info,

fs/btrfs/transaction.c

1671

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

1674

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/transaction.c

169

spin_lock(&transaction->fs_info->unused_bgs_lock);

fs/btrfs/transaction.c

171

spin_unlock(&transaction->fs_info->unused_bgs_lock);

fs/btrfs/transaction.c

1724

pending->error = btrfs_block_rsv_add(fs_info,

fs/btrfs/transaction.c

1735

trace_btrfs_space_reservation(fs_info, "transaction",

fs/btrfs/transaction.c

1769

if (unlikely(ret != -ENOTCONN || btrfs_qgroup_enabled(fs_info))) {

fs/btrfs/transaction.c

183

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

1858

pending->snap = btrfs_get_new_fs_root(fs_info, objectid, &pending->anon_dev);

fs/btrfs/transaction.c

1878

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_FULL)

fs/btrfs/transaction.c

1881

else if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/transaction.c

193

down_write(&fs_info->commit_root_sem);

fs/btrfs/transaction.c

195

if (test_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags))

fs/btrfs/transaction.c

196

fs_info->last_reloc_trans = trans->transid;

fs/btrfs/transaction.c

1972

static void update_super_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

1977

super = fs_info->super_copy;

fs/btrfs/transaction.c

1979

root_item = &fs_info->chunk_root->root_item;

fs/btrfs/transaction.c

1984

root_item = &fs_info->tree_root->root_item;

fs/btrfs/transaction.c

1988

if (btrfs_test_opt(fs_info, SPACE_CACHE))

fs/btrfs/transaction.c

1990

else if (test_bit(BTRFS_FS_CLEANUP_SPACE_CACHE_V1, &fs_info->flags))

fs/btrfs/transaction.c

1992

if (test_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags))

fs/btrfs/transaction.c

1995

if (btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/transaction.c

1996

root_item = &fs_info->remap_root->root_item;

fs/btrfs/transaction.c

2018

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

2022

set_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags);

fs/btrfs/transaction.c

2023

wake_up_process(fs_info->transaction_kthread);

fs/btrfs/transaction.c

2035

btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_PREP);

fs/btrfs/transaction.c

2036

wait_event(fs_info->transaction_blocked_wait,

fs/btrfs/transaction.c

2063

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

2070

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2079

if (cur_trans == fs_info->running_transaction) {

fs/btrfs/transaction.c

2081

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2087

btrfs_might_wait_for_event(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

2091

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2104

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2108

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2109

if (cur_trans == fs_info->running_transaction)

fs/btrfs/transaction.c

2110

fs_info->running_transaction = NULL;

fs/btrfs/transaction.c

2111

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2114

sb_end_intwrite(fs_info->sb);

fs/btrfs/transaction.c

2134

if (!test_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags))

fs/btrfs/transaction.c

2135

btrfs_scrub_cancel(fs_info);

fs/btrfs/transaction.c

2147

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

215

btrfs_drop_and_free_fs_root(fs_info, root);

fs/btrfs/transaction.c

2151

btrfs_dec_delayed_refs_rsv_bg_inserts(fs_info);

fs/btrfs/transaction.c

2156

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/transaction.c

2159

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/transaction.c

2163

static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

2182

if (btrfs_test_opt(fs_info, FLUSHONCOMMIT))

fs/btrfs/transaction.c

2183

try_to_writeback_inodes_sb(fs_info->sb, WB_REASON_SYNC);

fs/btrfs/transaction.c

2187

static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

2189

if (btrfs_test_opt(fs_info, FLUSHONCOMMIT))

fs/btrfs/transaction.c

2190

btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);

fs/btrfs/transaction.c

220

up_write(&fs_info->commit_root_sem);

fs/btrfs/transaction.c

2208

lockdep_assert_held(&trans->fs_info->trans_lock);

fs/btrfs/transaction.c

2215

static void update_commit_stats(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

2218

ktime_t interval = now - fs_info->commit_stats.critical_section_start_time;

fs/btrfs/transaction.c

2220

ASSERT(fs_info->commit_stats.critical_section_start_time);

fs/btrfs/transaction.c

2222

fs_info->commit_stats.commit_count++;

fs/btrfs/transaction.c

2223

fs_info->commit_stats.last_commit_dur = interval;

fs/btrfs/transaction.c

2224

fs_info->commit_stats.max_commit_dur =

fs/btrfs/transaction.c

2225

max_t(u64, fs_info->commit_stats.max_commit_dur, interval);

fs/btrfs/transaction.c

2226

fs_info->commit_stats.total_commit_dur += interval;

fs/btrfs/transaction.c

2227

fs_info->commit_stats.critical_section_start_time = 0;

fs/btrfs/transaction.c

2232

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

2239

btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_PREP);

fs/btrfs/transaction.c

2241

clear_bit(BTRFS_FS_NEED_TRANS_COMMIT, &fs_info->flags);

fs/btrfs/transaction.c

2285

mutex_lock(&fs_info->ro_block_group_mutex);

fs/btrfs/transaction.c

2289

mutex_unlock(&fs_info->ro_block_group_mutex);

fs/btrfs/transaction.c

2298

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2304

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2310

btrfs_trans_state_lockdep_release(fs_info,

fs/btrfs/transaction.c

2325

wake_up(&fs_info->transaction_blocked_wait);

fs/btrfs/transaction.c

2326

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_PREP);

fs/btrfs/transaction.c

2328

if (!list_is_first(&cur_trans->list, &fs_info->trans_list)) {

fs/btrfs/transaction.c

2337

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2346

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2355

if (unlikely(BTRFS_FS_ERROR(fs_info))) {

fs/btrfs/transaction.c

2356

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2364

wake_up(&fs_info->transaction_blocked_wait);

fs/btrfs/transaction.c

2365

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2371

fs_info->commit_stats.critical_section_start_time = ktime_get_ns();

fs/btrfs/transaction.c

2374

ret = btrfs_start_delalloc_flush(fs_info);

fs/btrfs/transaction.c

2387

btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

2388

btrfs_might_wait_for_event(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

2395

btrfs_lockdep_release(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

2399

btrfs_wait_delalloc_flush(fs_info);

fs/btrfs/transaction.c

2406

btrfs_might_wait_for_event(fs_info, btrfs_trans_pending_ordered);

fs/btrfs/transaction.c

2410

btrfs_scrub_pause(fs_info);

fs/btrfs/transaction.c

2416

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2420

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2427

btrfs_lockdep_release(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

2428

btrfs_might_wait_for_event(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

2438

btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED);

fs/btrfs/transaction.c

2439

btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED);

fs/btrfs/transaction.c

2440

btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED);

fs/btrfs/transaction.c

2447

clear_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags);

fs/btrfs/transaction.c

2451

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED);

fs/btrfs/transaction.c

2459

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/transaction.c

2492

btrfs_assert_delayed_root_empty(fs_info);

fs/btrfs/transaction.c

2503

btrfs_free_log_root_tree(trans, fs_info);

fs/btrfs/transaction.c

2526

cur_trans = fs_info->running_transaction;

fs/btrfs/transaction.c

2528

btrfs_set_root_node(&fs_info->tree_root->root_item,

fs/btrfs/transaction.c

2529

fs_info->tree_root->node);

fs/btrfs/transaction.c

2530

list_add_tail(&fs_info->tree_root->dirty_list,

fs/btrfs/transaction.c

2533

btrfs_set_root_node(&fs_info->chunk_root->root_item,

fs/btrfs/transaction.c

2534

fs_info->chunk_root->node);

fs/btrfs/transaction.c

2535

list_add_tail(&fs_info->chunk_root->dirty_list,

fs/btrfs/transaction.c

2542

update_super_roots(fs_info);

fs/btrfs/transaction.c

2544

btrfs_set_super_log_root(fs_info->super_copy, 0);

fs/btrfs/transaction.c

2545

btrfs_set_super_log_root_level(fs_info->super_copy, 0);

fs/btrfs/transaction.c

2546

memcpy(fs_info->super_for_commit, fs_info->super_copy,

fs/btrfs/transaction.c

2547

sizeof(*fs_info->super_copy));

fs/btrfs/transaction.c

2551

clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags);

fs/btrfs/transaction.c

2552

clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags);

fs/btrfs/transaction.c

2564

mutex_lock(&fs_info->tree_log_mutex);

fs/btrfs/transaction.c

2566

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2569

fs_info->running_transaction = NULL;

fs/btrfs/transaction.c

257

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

2570

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2571

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/transaction.c

2573

wake_up(&fs_info->transaction_wait);

fs/btrfs/transaction.c

2574

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED);

fs/btrfs/transaction.c

2577

if (test_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags) &&

fs/btrfs/transaction.c

2578

fs_info->cleaner_kthread)

fs/btrfs/transaction.c

2579

wake_up_process(fs_info->cleaner_kthread);

fs/btrfs/transaction.c

2591

btrfs_err(fs_info, "error while writing out transaction: %d", ret);

fs/btrfs/transaction.c

2592

mutex_unlock(&fs_info->tree_log_mutex);

fs/btrfs/transaction.c

2601

mutex_unlock(&fs_info->tree_log_mutex);

fs/btrfs/transaction.c

2605

update_commit_stats(fs_info);

fs/btrfs/transaction.c

2613

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED);

fs/btrfs/transaction.c

262

btrfs_block_rsv_release(fs_info, &fs_info->chunk_block_rsv,

fs/btrfs/transaction.c

2620

btrfs_clear_space_info_full(fs_info);

fs/btrfs/transaction.c

2622

btrfs_set_last_trans_committed(fs_info, cur_trans->transid);

fs/btrfs/transaction.c

2630

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED);

fs/btrfs/transaction.c

2632

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2634

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2640

sb_end_intwrite(fs_info->sb);

fs/btrfs/transaction.c

2642

btrfs_scrub_continue(fs_info);

fs/btrfs/transaction.c

2652

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/transaction.c

2653

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED);

fs/btrfs/transaction.c

2655

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED);

fs/btrfs/transaction.c

2656

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED);

fs/btrfs/transaction.c

2657

btrfs_scrub_continue(fs_info);

fs/btrfs/transaction.c

2663

btrfs_warn(fs_info, "Skipping commit of aborted transaction.");

fs/btrfs/transaction.c

2669

btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

2670

btrfs_lockdep_release(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

2674

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_PREP);

fs/btrfs/transaction.c

2689

int btrfs_clean_one_deleted_snapshot(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

2694

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2695

if (list_empty(&fs_info->dead_roots)) {

fs/btrfs/transaction.c

2696

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2699

root = list_first_entry(&fs_info->dead_roots,

fs/btrfs/transaction.c

270

static noinline int join_transaction(struct btrfs_fs_info *fs_info,

fs/btrfs/transaction.c

2702

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2704

btrfs_debug(fs_info, "cleaner removing %llu", btrfs_root_id(root));

fs/btrfs/transaction.c

2740

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

275

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2752

btrfs_err(fs_info, "Transaction %llu aborted (error %d)",

fs/btrfs/transaction.c

2755

btrfs_dump_space_info_for_trans_abort(fs_info);

fs/btrfs/transaction.c

2758

wake_up(&fs_info->transaction_wait);

fs/btrfs/transaction.c

2759

wake_up(&fs_info->transaction_blocked_wait);

fs/btrfs/transaction.c

2760

__btrfs_handle_fs_error(fs_info, function, line, error, NULL);

fs/btrfs/transaction.c

278

if (unlikely(BTRFS_FS_ERROR(fs_info))) {

fs/btrfs/transaction.c

279

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

283

cur_trans = fs_info->running_transaction;

fs/btrfs/transaction.c

288

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

292

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

298

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

299

btrfs_lockdep_acquire(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

300

btrfs_lockdep_acquire(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

303

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

323

btrfs_lockdep_acquire(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

324

btrfs_lockdep_acquire(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

326

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

327

if (fs_info->running_transaction) {

fs/btrfs/transaction.c

332

btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

333

btrfs_lockdep_release(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

336

} else if (unlikely(BTRFS_FS_ERROR(fs_info))) {

fs/btrfs/transaction.c

337

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

338

btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

339

btrfs_lockdep_release(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

344

cur_trans->fs_info = fs_info;

fs/btrfs/transaction.c

370

if (!list_empty(&fs_info->tree_mod_seq_list))

fs/btrfs/transaction.c

372

if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log))

fs/btrfs/transaction.c

374

atomic64_set(&fs_info->tree_mod_seq, 0);

fs/btrfs/transaction.c

388

list_add_tail(&cur_trans->list, &fs_info->trans_list);

fs/btrfs/transaction.c

389

btrfs_extent_io_tree_init(fs_info, &cur_trans->dirty_pages,

fs/btrfs/transaction.c

391

btrfs_extent_io_tree_init(fs_info, &cur_trans->pinned_extents,

fs/btrfs/transaction.c

393

btrfs_set_fs_generation(fs_info, fs_info->generation + 1);

fs/btrfs/transaction.c

394

cur_trans->transid = fs_info->generation;

fs/btrfs/transaction.c

395

fs_info->running_transaction = cur_trans;

fs/btrfs/transaction.c

398

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

413

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

432

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

434

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

437

radix_tree_tag_set(&fs_info->fs_roots_radix,

fs/btrfs/transaction.c

440

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

473

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

482

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

483

radix_tree_tag_clear(&fs_info->fs_roots_radix,

fs/btrfs/transaction.c

486

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

492

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

507

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/transaction.c

509

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/transaction.c

525

static void wait_current_trans(struct btrfs_fs_info *fs_info, unsigned int type)

fs/btrfs/transaction.c

529

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

530

cur_trans = fs_info->running_transaction;

fs/btrfs/transaction.c

534

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

536

btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED);

fs/btrfs/transaction.c

537

wait_event(fs_info->transaction_wait,

fs/btrfs/transaction.c

542

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

546

static bool may_wait_transaction(struct btrfs_fs_info *fs_info, int type)

fs/btrfs/transaction.c

548

if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))

fs/btrfs/transaction.c

559

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

561

if (!fs_info->reloc_ctl ||

fs/btrfs/transaction.c

570

static int btrfs_reserve_trans_metadata(struct btrfs_fs_info *fs_info,

fs/btrfs/transaction.c

575

struct btrfs_space_info *si = fs_info->trans_block_rsv.space_info;

fs/btrfs/transaction.c

604

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

605

struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/transaction.c

606

struct btrfs_block_rsv *trans_rsv = &fs_info->trans_block_rsv;

fs/btrfs/transaction.c

616

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/transaction.c

633

if (num_items && root != fs_info->chunk_root) {

fs/btrfs/transaction.c

634

qgroup_reserved = (num_items << fs_info->nodesize_bits);

fs/btrfs/transaction.c

645

num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items);

fs/btrfs/transaction.c

654

delayed_refs_bytes = btrfs_calc_delayed_ref_bytes(fs_info, num_items);

fs/btrfs/transaction.c

660

num_bytes += fs_info->nodesize;

fs/btrfs/transaction.c

664

ret = btrfs_reserve_trans_metadata(fs_info, flush, num_bytes,

fs/btrfs/transaction.c

682

ret = btrfs_delayed_refs_rsv_refill(fs_info, flush);

fs/btrfs/transaction.c

684

ASSERT(btrfs_is_zoned(fs_info));

fs/btrfs/transaction.c

688

ret = btrfs_delayed_refs_rsv_refill(fs_info, flush);

fs/btrfs/transaction.c

714

sb_start_intwrite(fs_info->sb);

fs/btrfs/transaction.c

716

if (may_wait_transaction(fs_info, type))

fs/btrfs/transaction.c

717

wait_current_trans(fs_info, type);

fs/btrfs/transaction.c

720

ret = join_transaction(fs_info, type);

fs/btrfs/transaction.c

722

wait_current_trans(fs_info, type);

fs/btrfs/transaction.c

732

cur_trans = fs_info->running_transaction;

fs/btrfs/transaction.c

737

h->fs_info = root->fs_info;

fs/btrfs/transaction.c

741

btrfs_init_metadata_block_rsv(fs_info, &h->delayed_rsv, BTRFS_BLOCK_RSV_DELREFS);

fs/btrfs/transaction.c

745

may_wait_transaction(fs_info, type)) {

fs/btrfs/transaction.c

752

trace_btrfs_space_reservation(fs_info, "transaction",

fs/btrfs/transaction.c

757

trace_btrfs_space_reservation(fs_info,

fs/btrfs/transaction.c

782

btrfs_chunk_alloc(h, space_info, btrfs_get_alloc_profile(fs_info, flags),

fs/btrfs/transaction.c

816

sb_end_intwrite(fs_info->sb);

fs/btrfs/transaction.c

820

btrfs_block_rsv_release(fs_info, trans_rsv, num_bytes, NULL);

fs/btrfs/transaction.c

904

ret = btrfs_wait_for_commit(root->fs_info, 0);

fs/btrfs/transaction.c

916

struct btrfs_fs_info *fs_info = commit->fs_info;

fs/btrfs/transaction.c

925

btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED);

fs/btrfs/transaction.c

927

btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED);

fs/btrfs/transaction.c

944

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

945

commit = list_first_entry_or_null(&fs_info->trans_list,

fs/btrfs/transaction.c

949

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

954

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

958

int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid)

fs/btrfs/transaction.c

964

if (transid <= btrfs_get_last_trans_committed(fs_info))

fs/btrfs/transaction.c

968

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

969

list_for_each_entry(t, &fs_info->trans_list, list) {

fs/btrfs/transaction.c

981

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

988

if (transid > btrfs_get_last_trans_committed(fs_info))

fs/btrfs/transaction.c

994

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

995

list_for_each_entry_reverse(t, &fs_info->trans_list,

fs/btrfs/transaction.h

111

struct btrfs_fs_info *fs_info;

fs/btrfs/transaction.h

163

struct btrfs_fs_info *fs_info;

fs/btrfs/transaction.h

281

&((trans)->fs_info->fs_state))) { \

fs/btrfs/transaction.h

301

int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid);

fs/btrfs/transaction.h

304

void btrfs_maybe_wake_unfinished_drop(struct btrfs_fs_info *fs_info);

fs/btrfs/transaction.h

305

int btrfs_clean_one_deleted_snapshot(struct btrfs_fs_info *fs_info);

fs/btrfs/transaction.h

311

void btrfs_throttle(struct btrfs_fs_info *fs_info);

fs/btrfs/transaction.h

314

int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-checker.c

1002

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1008

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1022

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1028

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1036

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1042

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1051

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1057

features = btrfs_super_incompat_flags(fs_info->super_copy);

fs/btrfs/tree-checker.c

1064

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1072

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1079

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1087

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1107

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

1111

chunk_err(fs_info, leaf, chunk, key->offset,

fs/btrfs/tree-checker.c

1115

BTRFS_LEAF_DATA_SIZE(fs_info));

fs/btrfs/tree-checker.c

1126

chunk_err(fs_info, leaf, chunk, key->offset,

fs/btrfs/tree-checker.c

1133

return btrfs_check_chunk_valid(fs_info, leaf, chunk, key->offset,

fs/btrfs/tree-checker.c

1134

fs_info->sectorsize);

fs/btrfs/tree-checker.c

1153

btrfs_crit(eb->fs_info,

fs/btrfs/tree-checker.c

1211

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

1213

u64 super_gen = btrfs_super_generation(fs_info->super_copy);

fs/btrfs/tree-checker.c

1287

if (unlikely(!sb_rdonly(fs_info->sb) &&

fs/btrfs/tree-checker.c

129

end = ALIGN(key->offset + len, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1300

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

1330

btrfs_super_generation(fs_info->super_copy) + 1)) {

fs/btrfs/tree-checker.c

1334

btrfs_super_generation(fs_info->super_copy) + 1);

fs/btrfs/tree-checker.c

1338

btrfs_super_generation(fs_info->super_copy) + 1)) {

fs/btrfs/tree-checker.c

1342

btrfs_super_generation(fs_info->super_copy) + 1);

fs/btrfs/tree-checker.c

1346

btrfs_super_generation(fs_info->super_copy) + 1)) {

fs/btrfs/tree-checker.c

1350

btrfs_super_generation(fs_info->super_copy) + 1);

fs/btrfs/tree-checker.c

1355

if (unlikely(!IS_ALIGNED(btrfs_root_bytenr(&ri), fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1358

btrfs_root_bytenr(&ri), fs_info->sectorsize);

fs/btrfs/tree-checker.c

1448

len = eb->fs_info->nodesize;

fs/btrfs/tree-checker.c

1457

btrfs_crit(eb->fs_info,

fs/btrfs/tree-checker.c

146

const struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/tree-checker.c

1481

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

1495

!btrfs_fs_incompat(fs_info, SKINNY_METADATA))) {

fs/btrfs/tree-checker.c

1501

if (unlikely(!IS_ALIGNED(key->objectid, fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1504

key->objectid, fs_info->sectorsize);

fs/btrfs/tree-checker.c

1552

BTRFS_LEAF_DATA_SIZE(fs_info));

fs/btrfs/tree-checker.c

1563

btrfs_super_generation(fs_info->super_copy) + 1)) {

fs/btrfs/tree-checker.c

1567

btrfs_super_generation(fs_info->super_copy) + 1);

fs/btrfs/tree-checker.c

158

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

1581

key->offset != fs_info->nodesize)) {

fs/btrfs/tree-checker.c

1584

key->offset, fs_info->nodesize);

fs/btrfs/tree-checker.c

1594

if (unlikely(!IS_ALIGNED(key->offset, fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1597

key->offset, fs_info->sectorsize);

fs/btrfs/tree-checker.c

1660

fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1663

inline_offset, fs_info->sectorsize);

fs/btrfs/tree-checker.c

1695

fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1698

dref_offset, fs_info->sectorsize);

fs/btrfs/tree-checker.c

1712

fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1715

inline_offset, fs_info->sectorsize);

fs/btrfs/tree-checker.c

1726

WARN_ON(!btrfs_fs_incompat(fs_info, SIMPLE_QUOTA));

fs/btrfs/tree-checker.c

1773

prev_end += fs_info->nodesize;

fs/btrfs/tree-checker.c

1814

if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1817

key->objectid, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1821

!IS_ALIGNED(key->offset, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1824

key->offset, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1844

if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1847

key->objectid, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1876

if (unlikely(!IS_ALIGNED(offset, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1879

offset, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1908

sizeof(*iref), BTRFS_LEAF_DATA_SIZE(leaf->fs_info));

fs/btrfs/tree-checker.c

1985

if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1988

key->objectid, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1992

if (unlikely(!btrfs_fs_incompat(leaf->fs_info, RAID_STRIPE_TREE))) {

fs/btrfs/tree-checker.c

2005

const u32 sectorsize = leaf->fs_info->sectorsize;

fs/btrfs/tree-checker.c

2008

if (unlikely(!btrfs_fs_incompat(leaf->fs_info, REMAP_TREE))) {

fs/btrfs/tree-checker.c

2072

const u32 sectorsize = leaf->fs_info->sectorsize;

fs/btrfs/tree-checker.c

211

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

213

u32 sectorsize = fs_info->sectorsize;

fs/btrfs/tree-checker.c

2135

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

2137

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/tree-checker.c

2176

key->offset >> fs_info->sectorsize_bits)) {

fs/btrfs/tree-checker.c

2180

key->offset >> fs_info->sectorsize_bits);

fs/btrfs/tree-checker.c

2189

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

2190

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/tree-checker.c

2291

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

2305

expected_item_size = DIV_ROUND_UP(key->offset >> fs_info->sectorsize_bits,

fs/btrfs/tree-checker.c

2406

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

2456

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))

fs/btrfs/tree-checker.c

2507

item_end_expected = BTRFS_LEAF_DATA_SIZE(fs_info);

fs/btrfs/tree-checker.c

2523

if (unlikely(item_data_end > BTRFS_LEAF_DATA_SIZE(fs_info))) {

fs/btrfs/tree-checker.c

2526

item_data_end, BTRFS_LEAF_DATA_SIZE(fs_info));

fs/btrfs/tree-checker.c

2567

struct btrfs_fs_info *fs_info = node->fs_info;

fs/btrfs/tree-checker.c

2585

if (unlikely(nr == 0 || nr > BTRFS_NODEPTRS_PER_BLOCK(fs_info))) {

fs/btrfs/tree-checker.c

2586

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

2590

BTRFS_NODEPTRS_PER_BLOCK(fs_info));

fs/btrfs/tree-checker.c

2604

if (unlikely(!IS_ALIGNED(bytenr, fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

2607

bytenr, fs_info->sectorsize);

fs/btrfs/tree-checker.c

2642

if (btrfs_is_testing(eb->fs_info))

fs/btrfs/tree-checker.c

2663

btrfs_crit(eb->fs_info,

fs/btrfs/tree-checker.c

2678

btrfs_crit(eb->fs_info,

fs/btrfs/tree-checker.c

2691

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/tree-checker.c

2699

btrfs_err(fs_info,

fs/btrfs/tree-checker.c

2714

if (btrfs_header_generation(eb) > btrfs_get_last_trans_committed(fs_info))

fs/btrfs/tree-checker.c

2719

btrfs_err(fs_info,

fs/btrfs/tree-checker.c

2734

btrfs_err(fs_info,

fs/btrfs/tree-checker.c

395

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

396

u32 sectorsize = fs_info->sectorsize;

fs/btrfs/tree-checker.c

397

const u32 csumsize = fs_info->csum_size;

fs/btrfs/tree-checker.c

552

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

59

const struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/tree-checker.c

635

if (unlikely(name_len + data_len > BTRFS_MAX_XATTR_SIZE(fs_info))) {

fs/btrfs/tree-checker.c

639

BTRFS_MAX_XATTR_SIZE(fs_info));

fs/btrfs/tree-checker.c

689

const struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/tree-checker.c

69

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

701

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

712

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

730

if (btrfs_fs_incompat(fs_info, REMAP_TREE))

fs/btrfs/tree-checker.c

745

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/tree-checker.c

752

if (unlikely(fs_info->nr_global_roots &&

fs/btrfs/tree-checker.c

753

chunk_objectid >= fs_info->nr_global_roots)) {

fs/btrfs/tree-checker.c

757

fs_info->nr_global_roots);

fs/btrfs/tree-checker.c

785

!btrfs_fs_incompat(fs_info, REMAP_TREE))) {

fs/btrfs/tree-checker.c

808

if (unlikely(!btrfs_fs_incompat(fs_info, REMAP_TREE) &&

fs/btrfs/tree-checker.c

815

if (unlikely(!btrfs_fs_incompat(fs_info, REMAP_TREE) &&

fs/btrfs/tree-checker.c

839

key->offset >> fs_info->sectorsize_bits)) {

fs/btrfs/tree-checker.c

843

key->offset >> fs_info->sectorsize_bits);

fs/btrfs/tree-checker.c

85

const struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/tree-checker.c

853

static void chunk_err(const struct btrfs_fs_info *fs_info,

fs/btrfs/tree-checker.c

882

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

886

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

928

int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info,

fs/btrfs/tree-checker.c

968

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

97

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

973

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

979

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

985

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

991

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

997

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.h

75

int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info,

fs/btrfs/tree-log.c

164

struct btrfs_fs_info *fs_info = wc->trans->fs_info;

fs/btrfs/tree-log.c

177

if (test_and_set_bit(BTRFS_FS_STATE_LOG_REPLAY_ABORTED, &fs_info->fs_state))

fs/btrfs/tree-log.c

183

btrfs_crit(fs_info,

fs/btrfs/tree-log.c

190

btrfs_crit(fs_info,

fs/btrfs/tree-log.c

201

btrfs_crit(fs_info,

fs/btrfs/tree-log.c

280

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tree-log.c

281

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/tree-log.c

282

const bool zoned = btrfs_is_zoned(fs_info);

fs/btrfs/tree-log.c

2872

root->fs_info->sectorsize);

fs/btrfs/tree-log.c

292

if (!fs_info->log_root_tree) {

fs/btrfs/tree-log.c

293

ret = btrfs_init_log_root_tree(trans, fs_info);

fs/btrfs/tree-log.c

2948

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/tree-log.c

2965

bg = btrfs_lookup_block_group(fs_info, eb->start);

fs/btrfs/tree-log.c

2967

btrfs_err(fs_info, "unable to find block group for %llu", eb->start);

fs/btrfs/tree-log.c

2968

btrfs_handle_fs_error(fs_info, -ENOENT, NULL);

fs/btrfs/tree-log.c

2974

bg->reserved -= fs_info->nodesize;

fs/btrfs/tree-log.c

2975

bg->space_info->bytes_reserved -= fs_info->nodesize;

fs/btrfs/tree-log.c

2988

struct btrfs_fs_info *fs_info = wc->log->fs_info;

fs/btrfs/tree-log.c

3013

next = btrfs_find_create_tree_block(fs_info, bytenr,

fs/btrfs/tree-log.c

3021

btrfs_handle_fs_error(fs_info, ret, NULL);

fs/btrfs/tree-log.c

3040

btrfs_handle_fs_error(fs_info, ret, NULL);

fs/btrfs/tree-log.c

3059

btrfs_handle_fs_error(fs_info, ret, NULL);

fs/btrfs/tree-log.c

3170

struct btrfs_fs_info *fs_info = log->fs_info;

fs/btrfs/tree-log.c

3175

ret = btrfs_insert_root(trans, fs_info->log_root_tree,

fs/btrfs/tree-log.c

3178

ret = btrfs_update_root(trans, fs_info->log_root_tree,

fs/btrfs/tree-log.c

3255

ctx->scratch_eb = alloc_dummy_extent_buffer(inode->root->fs_info, 0);

fs/btrfs/tree-log.c

3314

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tree-log.c

3316

struct btrfs_root *log_root_tree = fs_info->log_root_tree;

fs/btrfs/tree-log.c

3351

if (!btrfs_test_opt(fs_info, SSD) &&

fs/btrfs/tree-log.c

3379

ret = btrfs_write_marked_extents(fs_info, &log->dirty_log_pages, mark);

fs/btrfs/tree-log.c

3389

if (ret == -EAGAIN && btrfs_is_zoned(fs_info))

fs/btrfs/tree-log.c

3425

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/tree-log.c

3426

mutex_lock(&fs_info->tree_root->log_mutex);

fs/btrfs/tree-log.c

3431

mutex_unlock(&fs_info->tree_root->log_mutex);

fs/btrfs/tree-log.c

3436

mutex_unlock(&fs_info->tree_root->log_mutex);

fs/btrfs/tree-log.c

3459

btrfs_err(fs_info,

fs/btrfs/tree-log.c

3510

ret = btrfs_write_marked_extents(fs_info,

fs/btrfs/tree-log.c

3519

if (ret == -EAGAIN && btrfs_is_zoned(fs_info)) {

fs/btrfs/tree-log.c

3562

mutex_lock(&fs_info->tree_log_mutex);

fs/btrfs/tree-log.c

3571

if (unlikely(BTRFS_FS_ERROR(fs_info))) {

fs/btrfs/tree-log.c

3576

mutex_unlock(&fs_info->tree_log_mutex);

fs/btrfs/tree-log.c

3580

btrfs_set_super_log_root(fs_info->super_for_commit, log_root_start);

fs/btrfs/tree-log.c

3581

btrfs_set_super_log_root_level(fs_info->super_for_commit, log_root_level);

fs/btrfs/tree-log.c

3583

mutex_unlock(&fs_info->tree_log_mutex);

fs/btrfs/tree-log.c

3655

&log->fs_info->fs_state);

fs/btrfs/tree-log.c

366

const bool zoned = btrfs_is_zoned(root->fs_info);

fs/btrfs/tree-log.c

3665

btrfs_write_marked_extents(log->fs_info,

fs/btrfs/tree-log.c

3674

btrfs_handle_fs_error(log->fs_info, ret, NULL);

fs/btrfs/tree-log.c

3697

void btrfs_free_log_root_tree(struct btrfs_trans_handle *trans, struct btrfs_fs_info *fs_info)

fs/btrfs/tree-log.c

3699

if (fs_info->log_root_tree) {

fs/btrfs/tree-log.c

3700

free_log_tree(trans, fs_info->log_root_tree);

fs/btrfs/tree-log.c

3701

fs_info->log_root_tree = NULL;

fs/btrfs/tree-log.c

3702

clear_bit(BTRFS_ROOT_HAS_LOG_TREE, &fs_info->tree_root->state);

fs/btrfs/tree-log.c

418

struct btrfs_fs_info *fs_info = log->fs_info;

fs/btrfs/tree-log.c

425

if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {

fs/btrfs/tree-log.c

436

btrfs_handle_fs_error(fs_info, ret, NULL);

fs/btrfs/tree-log.c

4910

csum_root = btrfs_csum_root(trans->fs_info, disk_bytenr);

fs/btrfs/tree-log.c

4912

btrfs_err(trans->fs_info,

fs/btrfs/tree-log.c

5112

csum_root = btrfs_csum_root(trans->fs_info, block_start);

fs/btrfs/tree-log.c

5114

btrfs_err(trans->fs_info,

fs/btrfs/tree-log.c

5615

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tree-log.c

5622

if (!btrfs_fs_incompat(fs_info, NO_HOLES) || i_size == 0)

fs/btrfs/tree-log.c

5691

hole_len = ALIGN(i_size - prev_extent_end, fs_info->sectorsize);

fs/btrfs/tree-log.c

6578

const int leaf_data_size = BTRFS_LEAF_DATA_SIZE(trans->fs_info);

fs/btrfs/tree-log.c

711

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tree-log.c

737

extent_end = ALIGN(start + nbytes, fs_info->sectorsize);

fs/btrfs/tree-log.c

7608

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tree-log.c

7614

if (btrfs_test_opt(fs_info, NOTREELOG)) {

fs/btrfs/tree-log.c

7766

struct btrfs_fs_info *fs_info = log_root_tree->fs_info;

fs/btrfs/tree-log.c

7776

set_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags);

fs/btrfs/tree-log.c

7778

trans = btrfs_start_transaction(fs_info->tree_root, 0);

fs/btrfs/tree-log.c

7828

wc.root = btrfs_get_fs_root(fs_info, found_key.offset, true);

fs/btrfs/tree-log.c

7929

clear_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags);

fs/btrfs/tree-log.c

7936

clear_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags);

fs/btrfs/tree-log.c

814

btrfs_fs_incompat(fs_info, NO_HOLES))

fs/btrfs/tree-log.c

867

ret = btrfs_lookup_data_extent(fs_info, ins.objectid, ins.offset);

fs/btrfs/tree-log.c

975

csum_root = btrfs_csum_root(fs_info, sums->logical);

fs/btrfs/tree-log.c

977

btrfs_err(fs_info,

fs/btrfs/tree-log.h

70

WRITE_ONCE(trans->fs_info->last_trans_log_full_commit, trans->transid);

fs/btrfs/tree-log.h

75

return READ_ONCE(trans->fs_info->last_trans_log_full_commit) ==

fs/btrfs/tree-log.h

82

void btrfs_free_log_root_tree(struct btrfs_trans_handle *trans, struct btrfs_fs_info *fs_info);

fs/btrfs/tree-mod-log.c

1008

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tree-mod-log.c

102

if (list_empty(&fs_info->tree_mod_seq_list)) {

fs/btrfs/tree-mod-log.c

103

clear_bit(BTRFS_FS_TREE_MOD_LOG_USERS, &fs_info->flags);

fs/btrfs/tree-mod-log.c

1034

tm = tree_mod_log_search(fs_info, logical, time_seq);

fs/btrfs/tree-mod-log.c

1044

old = read_tree_block(fs_info, logical, &check);

fs/btrfs/tree-mod-log.c

1046

btrfs_warn(fs_info,

fs/btrfs/tree-mod-log.c

1064

tm2 = tree_mod_log_search(fs_info, logical, time_seq);

fs/btrfs/tree-mod-log.c

107

first = list_first_entry(&fs_info->tree_mod_seq_list,

fs/btrfs/tree-mod-log.c

1079

eb = alloc_dummy_extent_buffer(fs_info, logical);

fs/btrfs/tree-mod-log.c

1099

tree_mod_log_rewind(fs_info, eb, time_seq, tm);

fs/btrfs/tree-mod-log.c

1102

WARN_ON(btrfs_header_nritems(eb) > BTRFS_NODEPTRS_PER_BLOCK(fs_info));

fs/btrfs/tree-mod-log.c

1131

u64 btrfs_tree_mod_log_lowest_seq(struct btrfs_fs_info *fs_info)

fs/btrfs/tree-mod-log.c

1135

read_lock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

1136

if (!list_empty(&fs_info->tree_mod_seq_list)) {

fs/btrfs/tree-mod-log.c

1139

elem = list_first_entry(&fs_info->tree_mod_seq_list,

fs/btrfs/tree-mod-log.c

114

write_unlock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

1143

read_unlock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

124

tm_root = &fs_info->tree_mod_log;

fs/btrfs/tree-mod-log.c

133

write_unlock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

144

static noinline int tree_mod_log_insert(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.c

152

lockdep_assert_held_write(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

154

tm->seq = btrfs_inc_tree_mod_seq(fs_info);

fs/btrfs/tree-mod-log.c

156

tm_root = &fs_info->tree_mod_log;

fs/btrfs/tree-mod-log.c

208

static bool tree_mod_dont_log(struct btrfs_fs_info *fs_info, const struct extent_buffer *eb)

fs/btrfs/tree-mod-log.c

210

if (!test_bit(BTRFS_FS_TREE_MOD_LOG_USERS, &fs_info->flags))

fs/btrfs/tree-mod-log.c

215

write_lock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

216

if (list_empty(&(fs_info)->tree_mod_seq_list)) {

fs/btrfs/tree-mod-log.c

217

write_unlock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

225

static bool tree_mod_need_log(const struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.c

228

if (!test_bit(BTRFS_FS_TREE_MOD_LOG_USERS, &fs_info->flags))

fs/btrfs/tree-mod-log.c

267

if (!tree_mod_need_log(eb->fs_info, eb))

fs/btrfs/tree-mod-log.c

274

if (tree_mod_dont_log(eb->fs_info, eb)) {

fs/btrfs/tree-mod-log.c

289

ret = tree_mod_log_insert(eb->fs_info, tm);

fs/btrfs/tree-mod-log.c

291

write_unlock(&eb->fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

328

if (!tree_mod_need_log(eb->fs_info, eb))

fs/btrfs/tree-mod-log.c

354

if (tree_mod_dont_log(eb->fs_info, eb)) {

fs/btrfs/tree-mod-log.c

377

ret = tree_mod_log_insert(eb->fs_info, tm_list[i]);

fs/btrfs/tree-mod-log.c

382

ret = tree_mod_log_insert(eb->fs_info, tm);

fs/btrfs/tree-mod-log.c

385

write_unlock(&eb->fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

394

rb_erase(&tm_list[i]->node, &eb->fs_info->tree_mod_log);

fs/btrfs/tree-mod-log.c

399

write_unlock(&eb->fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

406

static int tree_mod_log_free_eb(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.c

414

ret = tree_mod_log_insert(fs_info, tm_list[i]);

fs/btrfs/tree-mod-log.c

418

&fs_info->tree_mod_log);

fs/btrfs/tree-mod-log.c

430

struct btrfs_fs_info *fs_info = old_root->fs_info;

fs/btrfs/tree-mod-log.c

437

if (!tree_mod_need_log(fs_info, NULL))

fs/btrfs/tree-mod-log.c

471

if (tree_mod_dont_log(fs_info, NULL)) {

fs/btrfs/tree-mod-log.c

487

ret = tree_mod_log_free_eb(fs_info, tm_list, nritems);

fs/btrfs/tree-mod-log.c

489

ret = tree_mod_log_insert(fs_info, tm);

fs/btrfs/tree-mod-log.c

492

write_unlock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

510

static struct tree_mod_elem *__tree_mod_log_search(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.c

519

read_lock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

520

tm_root = &fs_info->tree_mod_log;

fs/btrfs/tree-mod-log.c

547

read_unlock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

557

static struct tree_mod_elem *tree_mod_log_search_oldest(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.c

560

return __tree_mod_log_search(fs_info, start, min_seq, true);

fs/btrfs/tree-mod-log.c

568

static struct tree_mod_elem *tree_mod_log_search(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.c

571

return __tree_mod_log_search(fs_info, start, min_seq, false);

fs/btrfs/tree-mod-log.c

58

static u64 btrfs_inc_tree_mod_seq(struct btrfs_fs_info *fs_info)

fs/btrfs/tree-mod-log.c

580

struct btrfs_fs_info *fs_info = dst->fs_info;

fs/btrfs/tree-mod-log.c

592

if (!tree_mod_need_log(fs_info, NULL))

fs/btrfs/tree-mod-log.c

60

return atomic64_inc_return(&fs_info->tree_mod_seq);

fs/btrfs/tree-mod-log.c

643

if (tree_mod_dont_log(fs_info, NULL)) {

fs/btrfs/tree-mod-log.c

661

ret = tree_mod_log_insert(fs_info, dst_move_tm);

fs/btrfs/tree-mod-log.c

666

ret = tree_mod_log_insert(fs_info, tm_list_rem[i]);

fs/btrfs/tree-mod-log.c

669

ret = tree_mod_log_insert(fs_info, tm_list_add[i]);

fs/btrfs/tree-mod-log.c

674

ret = tree_mod_log_insert(fs_info, src_move_tm);

fs/btrfs/tree-mod-log.c

679

write_unlock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

686

rb_erase(&dst_move_tm->node, &fs_info->tree_mod_log);

fs/btrfs/tree-mod-log.c

689

rb_erase(&src_move_tm->node, &fs_info->tree_mod_log);

fs/btrfs/tree-mod-log.c

694

rb_erase(&tm_list[i]->node, &fs_info->tree_mod_log);

fs/btrfs/tree-mod-log.c

699

write_unlock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

71

u64 btrfs_get_tree_mod_seq(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.c

712

if (!tree_mod_need_log(eb->fs_info, eb))

fs/btrfs/tree-mod-log.c

732

if (tree_mod_dont_log(eb->fs_info, eb)) {

fs/btrfs/tree-mod-log.c

74

write_lock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

747

ret = tree_mod_log_free_eb(eb->fs_info, tm_list, nritems);

fs/btrfs/tree-mod-log.c

749

write_unlock(&eb->fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

76

elem->seq = btrfs_inc_tree_mod_seq(fs_info);

fs/btrfs/tree-mod-log.c

77

list_add_tail(&elem->list, &fs_info->tree_mod_seq_list);

fs/btrfs/tree-mod-log.c

78

set_bit(BTRFS_FS_TREE_MOD_LOG_USERS, &fs_info->flags);

fs/btrfs/tree-mod-log.c

788

tm = tree_mod_log_search_oldest(eb_root->fs_info, root_logical,

fs/btrfs/tree-mod-log.c

80

write_unlock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

826

static void tree_mod_log_rewind(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.c

85

void btrfs_put_tree_mod_seq(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.c

855

read_lock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

907

btrfs_warn(fs_info,

fs/btrfs/tree-mod-log.c

936

read_unlock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

947

struct extent_buffer *btrfs_tree_mod_log_rewind(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.c

960

tm = tree_mod_log_search(fs_info, eb->start, time_seq);

fs/btrfs/tree-mod-log.c

966

eb_rewin = alloc_dummy_extent_buffer(fs_info, eb->start);

fs/btrfs/tree-mod-log.c

98

write_lock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

992

tree_mod_log_rewind(fs_info, eb_rewin, time_seq, tm);

fs/btrfs/tree-mod-log.c

994

BTRFS_NODEPTRS_PER_BLOCK(fs_info));

fs/btrfs/tree-mod-log.h

33

u64 btrfs_get_tree_mod_seq(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.h

35

void btrfs_put_tree_mod_seq(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.h

43

struct extent_buffer *btrfs_tree_mod_log_rewind(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-mod-log.h

56

u64 btrfs_tree_mod_log_lowest_seq(struct btrfs_fs_info *fs_info);

fs/btrfs/uuid-tree.c

119

btrfs_warn(fs_info,

fs/btrfs/uuid-tree.c

133

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/uuid-tree.c

134

struct btrfs_root *uuid_root = fs_info->uuid_root;

fs/btrfs/uuid-tree.c

157

btrfs_warn(fs_info, "error %d while searching for uuid item!",

fs/btrfs/uuid-tree.c

169

btrfs_warn(fs_info, "uuid item with illegal size %lu!",

fs/btrfs/uuid-tree.c

206

int btrfs_uuid_tree_check_overflow(struct btrfs_fs_info *fs_info,

fs/btrfs/uuid-tree.c

214

if (WARN_ON_ONCE(!fs_info->uuid_root))

fs/btrfs/uuid-tree.c

222

ret = btrfs_search_slot(NULL, fs_info->uuid_root, &key, path, 0, 0);

fs/btrfs/uuid-tree.c

231

BTRFS_LEAF_DATA_SIZE(fs_info))

fs/btrfs/uuid-tree.c

261

static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info,

fs/btrfs/uuid-tree.c

271

subvol_root = btrfs_get_fs_root(fs_info, subvolid, true);

fs/btrfs/uuid-tree.c

295

int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info)

fs/btrfs/uuid-tree.c

297

struct btrfs_root *root = fs_info->uuid_root;

fs/btrfs/uuid-tree.c

322

if (btrfs_fs_closing(fs_info))

fs/btrfs/uuid-tree.c

337

btrfs_warn(fs_info,

fs/btrfs/uuid-tree.c

352

ret = btrfs_check_uuid_tree_entry(fs_info, uuid,

fs/btrfs/uuid-tree.c

393

struct btrfs_fs_info *fs_info = data;

fs/btrfs/uuid-tree.c

394

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/uuid-tree.c

416

if (btrfs_fs_closing(fs_info)) {

fs/btrfs/uuid-tree.c

456

trans = btrfs_start_transaction(fs_info->uuid_root, 2);

fs/btrfs/uuid-tree.c

472

btrfs_warn(fs_info, "uuid_tree_add failed %d",

fs/btrfs/uuid-tree.c

484

btrfs_warn(fs_info, "uuid_tree_add failed %d",

fs/btrfs/uuid-tree.c

519

btrfs_warn(fs_info, "btrfs_uuid_scan_kthread failed %d", ret);

fs/btrfs/uuid-tree.c

521

set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);

fs/btrfs/uuid-tree.c

522

up(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/uuid-tree.c

526

int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/uuid-tree.c

529

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/uuid-tree.c

550

fs_info->uuid_root = uuid_root;

fs/btrfs/uuid-tree.c

556

down(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/uuid-tree.c

557

task = kthread_run(btrfs_uuid_scan_kthread, fs_info, "btrfs-uuid");

fs/btrfs/uuid-tree.c

560

btrfs_warn(fs_info, "failed to start uuid_scan task");

fs/btrfs/uuid-tree.c

561

up(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/uuid-tree.c

58

btrfs_warn(uuid_root->fs_info,

fs/btrfs/uuid-tree.c

81

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/uuid-tree.c

82

struct btrfs_root *uuid_root = fs_info->uuid_root;

fs/btrfs/uuid-tree.h

15

int btrfs_uuid_tree_check_overflow(struct btrfs_fs_info *fs_info,

fs/btrfs/uuid-tree.h

17

int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info);

fs/btrfs/uuid-tree.h

18

int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info);

fs/btrfs/verity.c

459

btrfs_handle_fs_error(root->fs_info, ret,

fs/btrfs/verity.c

473

btrfs_handle_fs_error(root->fs_info, ret,

fs/btrfs/verity.c

552

btrfs_set_fs_compat_ro(root->fs_info, VERITY);

fs/btrfs/verity.c

640

btrfs_err(inode->root->fs_info,

fs/btrfs/volumes.c

1167

device->fs_info = NULL;

fs/btrfs/volumes.c

1207

fs_devices->fs_info = NULL;

fs/btrfs/volumes.c

1538

lockdep_assert_held(&device->fs_info->chunk_mutex);

fs/btrfs/volumes.c

1583

lockdep_assert_held(&device->fs_info->chunk_mutex);

fs/btrfs/volumes.c

1817

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/volumes.c

1818

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/volumes.c

1958

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/volumes.c

1959

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/volumes.c

2006

static u64 find_next_chunk(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

2011

read_lock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

2012

n = rb_last(&fs_info->mapping_tree.rb_root);

fs/btrfs/volumes.c

2019

read_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

2024

static noinline int find_next_devid(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

2040

ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0);

fs/btrfs/volumes.c

2046

btrfs_err(fs_info, "corrupted chunk tree devid -1 matched");

fs/btrfs/volumes.c

2050

ret = btrfs_previous_item(fs_info->chunk_root, path,

fs/btrfs/volumes.c

2086

ret = btrfs_insert_empty_item(trans, trans->fs_info->chunk_root, path,

fs/btrfs/volumes.c

2113

write_extent_buffer(leaf, trans->fs_info->fs_devices->metadata_uuid,

fs/btrfs/volumes.c

2138

struct btrfs_root *root = device->fs_info->chunk_root;

fs/btrfs/volumes.c

2167

static int btrfs_check_raid_min_devices(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

2175

seq = read_seqbegin(&fs_info->profiles_lock);

fs/btrfs/volumes.c

2177

all_avail = fs_info->avail_data_alloc_bits |

fs/btrfs/volumes.c

2178

fs_info->avail_system_alloc_bits |

fs/btrfs/volumes.c

2179

fs_info->avail_metadata_alloc_bits;

fs/btrfs/volumes.c

2180

} while (read_seqretry(&fs_info->profiles_lock, seq));

fs/btrfs/volumes.c

2217

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/volumes.c

2220

next_device = btrfs_find_next_active_device(fs_info->fs_devices,

fs/btrfs/volumes.c

2224

if (fs_info->sb->s_bdev &&

fs/btrfs/volumes.c

2225

(fs_info->sb->s_bdev == device->bdev))

fs/btrfs/volumes.c

2226

fs_info->sb->s_bdev = next_device->bdev;

fs/btrfs/volumes.c

2228

if (fs_info->fs_devices->latest_dev->bdev == device->bdev)

fs/btrfs/volumes.c

2229

fs_info->fs_devices->latest_dev = next_device;

fs/btrfs/volumes.c

2236

static u64 btrfs_num_devices(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

2238

u64 num_devices = fs_info->fs_devices->num_devices;

fs/btrfs/volumes.c

2240

down_read(&fs_info->dev_replace.rwsem);

fs/btrfs/volumes.c

2241

if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) {

fs/btrfs/volumes.c

2245

up_read(&fs_info->dev_replace.rwsem);

fs/btrfs/volumes.c

2250

static void btrfs_scratch_superblock(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

2268

btrfs_warn(fs_info, "error clearing superblock number %d (%d)",

fs/btrfs/volumes.c

2272

void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info, struct btrfs_device *device)

fs/btrfs/volumes.c

2284

btrfs_scratch_superblock(fs_info, bdev, copy_num);

fs/btrfs/volumes.c

2297

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

2298

struct btrfs_root *dev_root = fs_info->dev_root;

fs/btrfs/volumes.c

2308

btrfs_warn(fs_info,

fs/btrfs/volumes.c

2318

btrfs_warn(fs_info,

fs/btrfs/volumes.c

2326

int btrfs_rm_device(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

2333

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

2337

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/volumes.c

2338

btrfs_err(fs_info, "device remove not supported on extent tree v2 yet");

fs/btrfs/volumes.c

2347

num_devices = btrfs_num_devices(fs_info);

fs/btrfs/volumes.c

2349

ret = btrfs_check_raid_min_devices(fs_info, num_devices - 1);

fs/btrfs/volumes.c

2353

device = btrfs_find_device(fs_info->fs_devices, args);

fs/btrfs/volumes.c

2362

if (btrfs_pinned_by_swapfile(fs_info, device)) {

fs/btrfs/volumes.c

2363

btrfs_warn(fs_info,

fs/btrfs/volumes.c

2373

fs_info->fs_devices->rw_devices == 1)

fs/btrfs/volumes.c

2377

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2380

btrfs_update_per_profile_avail(fs_info);

fs/btrfs/volumes.c

2381

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2388

trans = btrfs_start_transaction(fs_info->chunk_root, 0);

fs/btrfs/volumes.c

2397

btrfs_crit(fs_info,

fs/btrfs/volumes.c

2450

num_devices = btrfs_super_num_devices(fs_info->super_copy) - 1;

fs/btrfs/volumes.c

2451

btrfs_set_super_num_devices(fs_info->super_copy, num_devices);

fs/btrfs/volumes.c

2465

btrfs_scratch_superblocks(fs_info, device);

fs/btrfs/volumes.c

2494

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2498

btrfs_update_per_profile_avail(fs_info);

fs/btrfs/volumes.c

2499

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2508

lockdep_assert_held(&srcdev->fs_info->fs_devices->device_list_mutex);

fs/btrfs/volumes.c

2560

struct btrfs_fs_devices *fs_devices = tgtdev->fs_info->fs_devices;

fs/btrfs/volumes.c

2577

btrfs_scratch_superblocks(tgtdev->fs_info, tgtdev);

fs/btrfs/volumes.c

2602

int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

261

static int btrfs_relocate_sys_chunks(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.c

2633

if (btrfs_fs_incompat(fs_info, METADATA_UUID))

fs/btrfs/volumes.c

2656

struct btrfs_fs_info *fs_info, u64 devid,

fs/btrfs/volumes.c

2665

device = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

2671

ret = btrfs_get_dev_args_from_path(fs_info, &args, device_path);

fs/btrfs/volumes.c

2674

device = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

2681

static struct btrfs_fs_devices *btrfs_init_sprout(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

2683

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

2726

static void btrfs_setup_sprout(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

2729

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

2730

struct btrfs_super_block *disk_super = fs_info->super_copy;

fs/btrfs/volumes.c

2781

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

2782

struct btrfs_root *root = fs_info->chunk_root;

fs/btrfs/volumes.c

2835

device = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

2848

int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path)

fs/btrfs/volumes.c

2850

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/volumes.c

2854

struct super_block *sb = fs_info->sb;

fs/btrfs/volumes.c

2855

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

2867

fs_info->sb, &fs_holder_ops);

fs/btrfs/volumes.c

2871

if (!btrfs_check_device_zone_type(fs_info, file_bdev(bdev_file))) {

fs/btrfs/volumes.c

2900

device = btrfs_alloc_device(fs_info, NULL, NULL, device_path);

fs/btrfs/volumes.c

2907

device->fs_info = fs_info;

fs/btrfs/volumes.c

2926

device->io_width = fs_info->sectorsize;

fs/btrfs/volumes.c

2927

device->io_align = fs_info->sectorsize;

fs/btrfs/volumes.c

2928

device->sector_size = fs_info->sectorsize;

fs/btrfs/volumes.c

2930

round_down(bdev_nr_bytes(device->bdev), fs_info->sectorsize);

fs/btrfs/volumes.c

2946

seed_devices = btrfs_init_sprout(fs_info);

fs/btrfs/volumes.c

2956

btrfs_setup_sprout(fs_info, seed_devices);

fs/btrfs/volumes.c

2957

btrfs_assign_next_active_device(fs_info->fs_devices->latest_dev,

fs/btrfs/volumes.c

2963

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2972

atomic64_add(device->total_bytes, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

2977

orig_super_total_bytes = btrfs_super_total_bytes(fs_info->super_copy);

fs/btrfs/volumes.c

2978

btrfs_set_super_total_bytes(fs_info->super_copy,

fs/btrfs/volumes.c

2980

fs_info->sectorsize));

fs/btrfs/volumes.c

2982

orig_super_num_devices = btrfs_super_num_devices(fs_info->super_copy);

fs/btrfs/volumes.c

2983

btrfs_set_super_num_devices(fs_info->super_copy,

fs/btrfs/volumes.c

2990

btrfs_clear_space_info_full(fs_info);

fs/btrfs/volumes.c

2992

btrfs_update_per_profile_avail(fs_info);

fs/btrfs/volumes.c

2993

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3001

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3003

btrfs_update_per_profile_avail(fs_info);

fs/btrfs/volumes.c

3004

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3041

ret = btrfs_relocate_sys_chunks(fs_info);

fs/btrfs/volumes.c

3043

btrfs_handle_fs_error(fs_info, ret,

fs/btrfs/volumes.c

3072

mutex_lock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/volumes.c

3073

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3076

fs_info->fs_devices->num_devices--;

fs/btrfs/volumes.c

3077

fs_info->fs_devices->open_devices--;

fs/btrfs/volumes.c

3078

fs_info->fs_devices->rw_devices--;

fs/btrfs/volumes.c

3079

fs_info->fs_devices->total_devices--;

fs/btrfs/volumes.c

3080

fs_info->fs_devices->total_rw_bytes -= device->total_bytes;

fs/btrfs/volumes.c

3081

atomic64_sub(device->total_bytes, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

3082

btrfs_set_super_total_bytes(fs_info->super_copy,

fs/btrfs/volumes.c

3084

btrfs_set_super_num_devices(fs_info->super_copy,

fs/btrfs/volumes.c

3086

btrfs_update_per_profile_avail(fs_info);

fs/btrfs/volumes.c

3087

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3088

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/volumes.c

3109

struct btrfs_root *root = device->fs_info->chunk_root;

fs/btrfs/volumes.c

3147

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/volumes.c

3148

struct btrfs_super_block *super_copy = fs_info->super_copy;

fs/btrfs/volumes.c

3156

new_size = round_down(new_size, fs_info->sectorsize);

fs/btrfs/volumes.c

3158

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3160

diff = round_down(new_size - device->total_bytes, fs_info->sectorsize);

fs/btrfs/volumes.c

3164

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3169

round_down(old_total + diff, fs_info->sectorsize));

fs/btrfs/volumes.c

3171

atomic64_add(diff, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

3175

btrfs_clear_space_info_full(device->fs_info);

fs/btrfs/volumes.c

3179

btrfs_update_per_profile_avail(fs_info);

fs/btrfs/volumes.c

3180

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3191

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

3192

struct btrfs_root *root = fs_info->chunk_root;

fs/btrfs/volumes.c

3210

btrfs_err(fs_info, "failed to lookup chunk %llu when freeing",

fs/btrfs/volumes.c

3218

btrfs_err(fs_info, "failed to delete chunk %llu item", chunk_offset);

fs/btrfs/volumes.c

3225

static int btrfs_del_sys_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset)

fs/btrfs/volumes.c

3227

struct btrfs_super_block *super_copy = fs_info->super_copy;

fs/btrfs/volumes.c

3238

lockdep_assert_held(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3271

struct btrfs_chunk_map *btrfs_find_chunk_map_nolock(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

3274

struct rb_node *node = fs_info->mapping_tree.rb_root.rb_node;

fs/btrfs/volumes.c

3334

struct btrfs_chunk_map *btrfs_find_chunk_map(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

3339

read_lock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

3340

map = btrfs_find_chunk_map_nolock(fs_info, logical, length);

fs/btrfs/volumes.c

3341

read_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

3354

struct btrfs_chunk_map *btrfs_get_chunk_map(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

3359

map = btrfs_find_chunk_map(fs_info, logical, length);

fs/btrfs/volumes.c

3362

btrfs_crit(fs_info,

fs/btrfs/volumes.c

3369

btrfs_crit(fs_info,

fs/btrfs/volumes.c

3391

lockdep_assert_held(&trans->fs_info->chunk_mutex);

fs/btrfs/volumes.c

3406

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

3407

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

3434

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3437

atomic64_add(dev_extent_len, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

3438

btrfs_clear_space_info_full(fs_info);

fs/btrfs/volumes.c

3445

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3455

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

3459

map = btrfs_get_chunk_map(fs_info, chunk_offset, 1);

fs/btrfs/volumes.c

3492

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3512

const u64 sys_flags = btrfs_system_alloc_profile(fs_info);

fs/btrfs/volumes.c

3516

space_info = btrfs_find_space_info(fs_info, sys_flags);

fs/btrfs/volumes.c

3546

trace_btrfs_chunk_free(fs_info, map, chunk_offset, map->chunk_len);

fs/btrfs/volumes.c

3549

ret = btrfs_del_sys_chunk(fs_info, chunk_offset);

fs/btrfs/volumes.c

3556

btrfs_update_per_profile_avail(fs_info);

fs/btrfs/volumes.c

3557

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3569

ASSERT(BTRFS_FS_ERROR(fs_info) != 0);

fs/btrfs/volumes.c

3573

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3581

static int btrfs_relocate_chunk_finish(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

3584

struct btrfs_root *root = fs_info->chunk_root;

fs/btrfs/volumes.c

3589

btrfs_discard_cancel_work(&fs_info->discard_ctl, bg);

fs/btrfs/volumes.c

3599

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/volumes.c

3600

ret = btrfs_discard_extent(fs_info, bg->start, length, NULL, true);

fs/btrfs/volumes.c

3602

btrfs_info(fs_info, "failed to reset zone %llu after relocation",

fs/btrfs/volumes.c

3606

trans = btrfs_start_trans_remove_block_group(root->fs_info, bg->start);

fs/btrfs/volumes.c

3609

btrfs_handle_fs_error(root->fs_info, ret, NULL);

fs/btrfs/volumes.c

3620

int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset, bool verbose)

fs/btrfs/volumes.c

3625

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/volumes.c

3626

btrfs_err(fs_info,

fs/btrfs/volumes.c

3643

lockdep_assert_held(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

3646

btrfs_scrub_pause(fs_info);

fs/btrfs/volumes.c

3647

ret = btrfs_relocate_block_group(fs_info, chunk_offset, verbose);

fs/btrfs/volumes.c

3648

btrfs_scrub_continue(fs_info);

fs/btrfs/volumes.c

3654

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/volumes.c

3655

btrfs_scrub_cancel(fs_info);

fs/btrfs/volumes.c

3659

block_group = btrfs_lookup_block_group(fs_info, chunk_offset);

fs/btrfs/volumes.c

3668

ret = btrfs_relocate_chunk_finish(fs_info, block_group);

fs/btrfs/volumes.c

3674

static int btrfs_relocate_sys_chunks(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

3676

struct btrfs_root *chunk_root = fs_info->chunk_root;

fs/btrfs/volumes.c

3697

mutex_lock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

3700

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

3711

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

3718

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

3733

ret = btrfs_relocate_chunk(fs_info, found_key.offset,

fs/btrfs/volumes.c

3740

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

3762

static int btrfs_may_alloc_data_chunk(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

3769

cache = btrfs_lookup_block_group(fs_info, chunk_offset);

fs/btrfs/volumes.c

3771

btrfs_err(fs_info, "balance: chunk at bytenr %llu has no corresponding block group",

fs/btrfs/volumes.c

3781

spin_lock(&fs_info->data_sinfo->lock);

fs/btrfs/volumes.c

3782

bytes_used = fs_info->data_sinfo->bytes_used;

fs/btrfs/volumes.c

3783

spin_unlock(&fs_info->data_sinfo->lock);

fs/btrfs/volumes.c

3789

trans = btrfs_join_transaction(fs_info->tree_root);

fs/btrfs/volumes.c

3841

static int insert_balance_item(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

3844

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/volumes.c

3894

static int del_balance_item(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

3896

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/volumes.c

3981

static void reset_balance_state(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

3983

struct btrfs_balance_control *bctl = fs_info->balance_ctl;

fs/btrfs/volumes.c

3986

ASSERT(fs_info->balance_ctl);

fs/btrfs/volumes.c

3988

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

3989

fs_info->balance_ctl = NULL;

fs/btrfs/volumes.c

3990

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

3993

ret = del_balance_item(fs_info);

fs/btrfs/volumes.c

3995

btrfs_handle_fs_error(fs_info, ret, NULL);

fs/btrfs/volumes.c

4013

static int chunk_usage_range_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,

fs/btrfs/volumes.c

4022

cache = btrfs_lookup_block_group(fs_info, chunk_offset);

fs/btrfs/volumes.c

4024

btrfs_err(fs_info, "balance: chunk at bytenr %llu has no corresponding block group",

fs/btrfs/volumes.c

4049

static int chunk_usage_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,

fs/btrfs/volumes.c

4056

cache = btrfs_lookup_block_group(fs_info, chunk_offset);

fs/btrfs/volumes.c

4058

btrfs_err(fs_info, "balance: chunk at bytenr %llu has no corresponding block group",

fs/btrfs/volumes.c

4180

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/volumes.c

4181

struct btrfs_balance_control *bctl = fs_info->balance_ctl;

fs/btrfs/volumes.c

4214

ret2 = chunk_usage_filter(fs_info, chunk_offset, bargs);

fs/btrfs/volumes.c

4222

ret2 = chunk_usage_range_filter(fs_info, chunk_offset, bargs);

fs/btrfs/volumes.c

4291

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

4295

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, 0, 1);

fs/btrfs/volumes.c

4300

ret = btrfs_next_leaf(fs_info->remap_root, path);

fs/btrfs/volumes.c

4312

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, 0, 1);

fs/btrfs/volumes.c

4320

static int balance_remap_chunks(struct btrfs_fs_info *fs_info, struct btrfs_path *path,

fs/btrfs/volumes.c

4328

rci->bg = btrfs_lookup_block_group(fs_info, rci->offset);

fs/btrfs/volumes.c

4345

trans = btrfs_start_transaction(fs_info->remap_root, 0);

fs/btrfs/volumes.c

4351

mutex_lock(&fs_info->remap_mutex);

fs/btrfs/volumes.c

4353

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/volumes.c

4392

static int __btrfs_balance(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

4394

struct btrfs_balance_control *bctl = fs_info->balance_ctl;

fs/btrfs/volumes.c

4395

struct btrfs_root *chunk_root = fs_info->chunk_root;

fs/btrfs/volumes.c

4425

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4427

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4443

if ((!counting && atomic_read(&fs_info->balance_pause_req)) ||

fs/btrfs/volumes.c

4444

atomic_read(&fs_info->balance_cancel_req)) {

fs/btrfs/volumes.c

4449

mutex_lock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4452

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4461

btrfs_err(fs_info,

fs/btrfs/volumes.c

4464

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4472

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4482

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4493

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4498

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4500

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4507

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4511

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4516

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4517

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4519

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4542

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4551

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4576

ret = btrfs_may_alloc_data_chunk(fs_info,

fs/btrfs/volumes.c

4579

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4586

ret = btrfs_relocate_chunk(fs_info, found_key.offset, true);

fs/btrfs/volumes.c

4587

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4591

btrfs_info(fs_info,

fs/btrfs/volumes.c

4598

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4600

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4616

ret = balance_remap_chunks(fs_info, path, &remap_chunks);

fs/btrfs/volumes.c

4621

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4623

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4628

btrfs_info(fs_info, "%d enospc errors during balance",

fs/btrfs/volumes.c

4665

static inline int validate_convert_profile(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

4677

btrfs_err(fs_info, "balance: invalid convert %s profile %s",

fs/btrfs/volumes.c

4780

static void describe_balance_start_or_resume(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

4788

struct btrfs_balance_control *bctl = fs_info->balance_ctl;

fs/btrfs/volumes.c

4829

btrfs_info(fs_info, "balance: %s %s",

fs/btrfs/volumes.c

4837

int btrfs_balance(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

4851

if (btrfs_fs_closing(fs_info) ||

fs/btrfs/volumes.c

4852

atomic_read(&fs_info->balance_pause_req) ||

fs/btrfs/volumes.c

4853

btrfs_should_cancel_balance(fs_info)) {

fs/btrfs/volumes.c

4858

allowed = btrfs_super_incompat_flags(fs_info->super_copy);

fs/btrfs/volumes.c

4871

btrfs_err(fs_info,

fs/btrfs/volumes.c

4882

num_devices = fs_info->fs_devices->rw_devices;

fs/btrfs/volumes.c

4894

if (!validate_convert_profile(fs_info, &bctl->data, allowed, "data") ||

fs/btrfs/volumes.c

4895

!validate_convert_profile(fs_info, &bctl->meta, allowed, "metadata") ||

fs/btrfs/volumes.c

4896

!validate_convert_profile(fs_info, &bctl->sys, allowed, "system")) {

fs/btrfs/volumes.c

4912

seq = read_seqbegin(&fs_info->profiles_lock);

fs/btrfs/volumes.c

4915

(fs_info->avail_system_alloc_bits & allowed) &&

fs/btrfs/volumes.c

4918

(fs_info->avail_metadata_alloc_bits & allowed) &&

fs/btrfs/volumes.c

4926

bctl->meta.target : fs_info->avail_metadata_alloc_bits;

fs/btrfs/volumes.c

4928

bctl->data.target : fs_info->avail_data_alloc_bits;

fs/btrfs/volumes.c

4929

} while (read_seqretry(&fs_info->profiles_lock, seq));

fs/btrfs/volumes.c

4933

btrfs_info(fs_info,

fs/btrfs/volumes.c

4936

btrfs_err(fs_info,

fs/btrfs/volumes.c

4945

btrfs_warn(fs_info,

fs/btrfs/volumes.c

4951

ret = insert_balance_item(fs_info, bctl);

fs/btrfs/volumes.c

4957

BUG_ON(fs_info->balance_ctl);

fs/btrfs/volumes.c

4958

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4959

fs_info->balance_ctl = bctl;

fs/btrfs/volumes.c

4960

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4963

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4965

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4968

ASSERT(!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags));

fs/btrfs/volumes.c

4969

set_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags);

fs/btrfs/volumes.c

4970

describe_balance_start_or_resume(fs_info);

fs/btrfs/volumes.c

4971

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

4973

ret = __btrfs_balance(fs_info);

fs/btrfs/volumes.c

4975

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

4976

if (ret == -ECANCELED && atomic_read(&fs_info->balance_pause_req)) {

fs/btrfs/volumes.c

4977

btrfs_info(fs_info, "balance: paused");

fs/btrfs/volumes.c

4978

btrfs_exclop_balance(fs_info, BTRFS_EXCLOP_BALANCE_PAUSED);

fs/btrfs/volumes.c

4997

btrfs_info(fs_info, "balance: canceled");

fs/btrfs/volumes.c

4999

btrfs_info(fs_info, "balance: ended with status: %d", ret);

fs/btrfs/volumes.c

5001

clear_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags);

fs/btrfs/volumes.c

5005

btrfs_update_ioctl_balance_args(fs_info, bargs);

fs/btrfs/volumes.c

5010

reset_balance_state(fs_info);

fs/btrfs/volumes.c

5011

btrfs_exclop_finish(fs_info);

fs/btrfs/volumes.c

5014

wake_up(&fs_info->balance_wait_q);

fs/btrfs/volumes.c

5019

reset_balance_state(fs_info);

fs/btrfs/volumes.c

5022

btrfs_exclop_finish(fs_info);

fs/btrfs/volumes.c

5029

struct btrfs_fs_info *fs_info = data;

fs/btrfs/volumes.c

5032

guard(super_write)(fs_info->sb);

fs/btrfs/volumes.c

5034

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5035

if (fs_info->balance_ctl)

fs/btrfs/volumes.c

5036

ret = btrfs_balance(fs_info, fs_info->balance_ctl, NULL);

fs/btrfs/volumes.c

5037

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5042

int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

5046

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5047

if (!fs_info->balance_ctl) {

fs/btrfs/volumes.c

5048

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5051

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5053

if (btrfs_test_opt(fs_info, SKIP_BALANCE)) {

fs/btrfs/volumes.c

5054

btrfs_info(fs_info, "balance: resume skipped");

fs/btrfs/volumes.c

5058

spin_lock(&fs_info->super_lock);

fs/btrfs/volumes.c

5059

ASSERT(fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED,

fs/btrfs/volumes.c

5060

"exclusive_operation=%d", fs_info->exclusive_operation);

fs/btrfs/volumes.c

5061

fs_info->exclusive_operation = BTRFS_EXCLOP_BALANCE;

fs/btrfs/volumes.c

5062

spin_unlock(&fs_info->super_lock);

fs/btrfs/volumes.c

5068

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

5069

fs_info->balance_ctl->flags |= BTRFS_BALANCE_RESUME;

fs/btrfs/volumes.c

5070

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

5072

tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance");

fs/btrfs/volumes.c

5076

int btrfs_recover_balance(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

5094

ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);

fs/btrfs/volumes.c

5128

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE_PAUSED))

fs/btrfs/volumes.c

5129

btrfs_warn(fs_info,

fs/btrfs/volumes.c

5134

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5135

BUG_ON(fs_info->balance_ctl);

fs/btrfs/volumes.c

5136

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

5137

fs_info->balance_ctl = bctl;

fs/btrfs/volumes.c

5138

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

5139

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5143

int btrfs_pause_balance(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

5147

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5148

if (!fs_info->balance_ctl) {

fs/btrfs/volumes.c

5149

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5153

if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) {

fs/btrfs/volumes.c

5154

atomic_inc(&fs_info->balance_pause_req);

fs/btrfs/volumes.c

5155

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5157

wait_event(fs_info->balance_wait_q,

fs/btrfs/volumes.c

5158

!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags));

fs/btrfs/volumes.c

5160

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5162

BUG_ON(test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags));

fs/btrfs/volumes.c

5163

atomic_dec(&fs_info->balance_pause_req);

fs/btrfs/volumes.c

5168

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5172

int btrfs_cancel_balance(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

5174

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5175

if (!fs_info->balance_ctl) {

fs/btrfs/volumes.c

5176

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5185

if (sb_rdonly(fs_info->sb)) {

fs/btrfs/volumes.c

5186

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5190

atomic_inc(&fs_info->balance_cancel_req);

fs/btrfs/volumes.c

5195

if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) {

fs/btrfs/volumes.c

5196

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5197

wait_event(fs_info->balance_wait_q,

fs/btrfs/volumes.c

5198

!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags));

fs/btrfs/volumes.c

5199

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5201

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5206

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5208

if (fs_info->balance_ctl) {

fs/btrfs/volumes.c

5209

reset_balance_state(fs_info);

fs/btrfs/volumes.c

5210

btrfs_exclop_finish(fs_info);

fs/btrfs/volumes.c

5211

btrfs_info(fs_info, "balance: canceled");

fs/btrfs/volumes.c

5215

ASSERT(!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags));

fs/btrfs/volumes.c

5216

atomic_dec(&fs_info->balance_cancel_req);

fs/btrfs/volumes.c

5217

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5228

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/volumes.c

5229

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/volumes.c

5241

struct btrfs_super_block *super_copy = fs_info->super_copy;

fs/btrfs/volumes.c

5249

new_size = round_down(new_size, fs_info->sectorsize);

fs/btrfs/volumes.c

5251

diff = round_down(old_size - new_size, fs_info->sectorsize);

fs/btrfs/volumes.c

5268

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5285

atomic64_sub(free_diff, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

5288

btrfs_update_per_profile_avail(fs_info);

fs/btrfs/volumes.c

5295

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5300

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5310

mutex_lock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5313

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5319

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5332

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5341

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5355

ret = btrfs_may_alloc_data_chunk(fs_info, chunk_offset);

fs/btrfs/volumes.c

5357

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5361

ret = btrfs_relocate_chunk(fs_info, chunk_offset, true);

fs/btrfs/volumes.c

5362

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5367

btrfs_warn(fs_info,

fs/btrfs/volumes.c

5391

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5403

round_down(old_total - diff, fs_info->sectorsize));

fs/btrfs/volumes.c

5404

btrfs_update_per_profile_avail(fs_info);

fs/btrfs/volumes.c

5405

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5420

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5424

atomic64_add(free_diff, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

5426

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5431

static int btrfs_add_system_chunk(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

5435

struct btrfs_super_block *super_copy = fs_info->super_copy;

fs/btrfs/volumes.c

5440

lockdep_assert_held(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5491

static int alloc_virtual_chunk(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

5497

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

5502

lockdep_assert_held(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5520

avail = round_down(avail, fs_info->sectorsize);

fs/btrfs/volumes.c

5553

ndevs = min(ndevs, (int)BTRFS_MAX_DEVS(fs_info));

fs/btrfs/volumes.c

5568

static int calc_one_profile_avail(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

5573

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

5579

lockdep_assert_held(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5597

while (!alloc_virtual_chunk(fs_info, devices_info, type, &allocated))

fs/btrfs/volumes.c

5609

void btrfs_update_per_profile_avail(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

5618

if (btrfs_is_zoned(fs_info))

fs/btrfs/volumes.c

5622

ret = calc_one_profile_avail(fs_info, i, &results[i]);

fs/btrfs/volumes.c

5627

spin_lock(&fs_info->fs_devices->per_profile_lock);

fs/btrfs/volumes.c

5629

fs_info->fs_devices->per_profile_avail[i] = results[i];

fs/btrfs/volumes.c

5630

spin_unlock(&fs_info->fs_devices->per_profile_lock);

fs/btrfs/volumes.c

5633

spin_lock(&fs_info->fs_devices->per_profile_lock);

fs/btrfs/volumes.c

5635

fs_info->fs_devices->per_profile_avail[i] = U64_MAX;

fs/btrfs/volumes.c

5636

spin_unlock(&fs_info->fs_devices->per_profile_lock);

fs/btrfs/volumes.c

5694

space_info = btrfs_find_space_info(fs_devices->fs_info, ctl->type);

fs/btrfs/volumes.c

5713

u64 zone_size = fs_devices->fs_info->zone_size;

fs/btrfs/volumes.c

5751

ctl->devs_max = BTRFS_MAX_DEVS(fs_devices->fs_info);

fs/btrfs/volumes.c

5775

struct btrfs_fs_info *info = fs_devices->fs_info;

fs/btrfs/volumes.c

5935

struct btrfs_fs_info *info = fs_devices->fs_info;

fs/btrfs/volumes.c

5990

void btrfs_remove_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map)

fs/btrfs/volumes.c

5992

write_lock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

5993

rb_erase_cached(&map->rb_node, &fs_info->mapping_tree);

fs/btrfs/volumes.c

5996

write_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

6018

int btrfs_add_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map)

fs/btrfs/volumes.c

6022

write_lock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

6023

exist = rb_find_add_cached(&map->rb_node, &fs_info->mapping_tree,

fs/btrfs/volumes.c

6027

write_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

6032

write_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

6056

struct btrfs_fs_info *info = trans->fs_info;

fs/btrfs/volumes.c

6125

struct btrfs_fs_info *info = trans->fs_info;

fs/btrfs/volumes.c

6181

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

6182

struct btrfs_root *chunk_root = fs_info->chunk_root;

fs/btrfs/volumes.c

6213

lockdep_assert_held(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

6215

map = btrfs_get_chunk_map(fs_info, bg->start, bg->length);

fs/btrfs/volumes.c

6257

btrfs_set_stack_chunk_sector_size(chunk, fs_info->sectorsize);

fs/btrfs/volumes.c

6271

ret = btrfs_add_system_chunk(fs_info, &key, chunk, item_size);

fs/btrfs/volumes.c

6284

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

6312

alloc_profile = btrfs_metadata_alloc_profile(fs_info);

fs/btrfs/volumes.c

6313

meta_space_info = btrfs_find_space_info(fs_info, alloc_profile);

fs/btrfs/volumes.c

6322

alloc_profile = btrfs_system_alloc_profile(fs_info);

fs/btrfs/volumes.c

6323

sys_space_info = btrfs_find_space_info(fs_info, alloc_profile);

fs/btrfs/volumes.c

6342

bool btrfs_chunk_writeable(struct btrfs_fs_info *fs_info, u64 chunk_offset)

fs/btrfs/volumes.c

6349

map = btrfs_get_chunk_map(fs_info, chunk_offset, 1);

fs/btrfs/volumes.c

6377

void btrfs_mapping_tree_free(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

6379

write_lock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

6380

while (!RB_EMPTY_ROOT(&fs_info->mapping_tree.rb_root)) {

fs/btrfs/volumes.c

6384

node = rb_first_cached(&fs_info->mapping_tree);

fs/btrfs/volumes.c

6386

rb_erase_cached(&map->rb_node, &fs_info->mapping_tree);

fs/btrfs/volumes.c

6391

cond_resched_rwlock_write(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

6393

write_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

6417

int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len)

fs/btrfs/volumes.c

6422

map = btrfs_get_chunk_map(fs_info, logical, len);

fs/btrfs/volumes.c

6437

unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6441

unsigned long len = fs_info->sectorsize;

fs/btrfs/volumes.c

6443

if (!btrfs_fs_incompat(fs_info, RAID56))

fs/btrfs/volumes.c

6446

map = btrfs_get_chunk_map(fs_info, logical, len);

fs/btrfs/volumes.c

6504

struct btrfs_fs_info *fs_info = device->fs_devices->fs_info;

fs/btrfs/volumes.c

6509

total_reads = percpu_counter_sum(&fs_info->stats_read_blocks);

fs/btrfs/volumes.c

6510

min_reads_per_dev = READ_ONCE(fs_info->fs_devices->rr_min_contig_read) >>

fs/btrfs/volumes.c

6511

fs_info->sectorsize_bits;

fs/btrfs/volumes.c

6526

static int find_live_mirror(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6530

const enum btrfs_read_policy policy = READ_ONCE(fs_info->fs_devices->read_policy);

fs/btrfs/volumes.c

6548

btrfs_warn_rl(fs_info, "unknown read_policy type %u, reset to pid",

fs/btrfs/volumes.c

6550

WRITE_ONCE(fs_info->fs_devices->read_policy, BTRFS_READ_POLICY_PID);

fs/btrfs/volumes.c

6566

fs_info->dev_replace.cont_reading_from_srcdev_mode ==

fs/btrfs/volumes.c

6568

srcdev = fs_info->dev_replace.srcdev;

fs/btrfs/volumes.c

6595

struct btrfs_io_context *alloc_btrfs_io_context(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6607

bioc->fs_info = fs_info;

fs/btrfs/volumes.c

6633

struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6655

map = btrfs_get_chunk_map(fs_info, logical, length);

fs/btrfs/volumes.c

6662

ret = btrfs_translate_remap(fs_info, &new_logical, &length);

fs/btrfs/volumes.c

6669

map = btrfs_get_chunk_map(fs_info, new_logical, length);

fs/btrfs/volumes.c

6788

static bool is_block_group_to_copy(struct btrfs_fs_info *fs_info, u64 logical)

fs/btrfs/volumes.c

6794

if (!btrfs_is_zoned(fs_info))

fs/btrfs/volumes.c

6797

cache = btrfs_lookup_block_group(fs_info, logical);

fs/btrfs/volumes.c

6824

if (is_block_group_to_copy(dev_replace->srcdev->fs_info, logical))

fs/btrfs/volumes.c

6933

static int set_io_stripe(struct btrfs_fs_info *fs_info, u64 logical,

fs/btrfs/volumes.c

6941

return btrfs_get_raid_extent_offset(fs_info, logical, length,

fs/btrfs/volumes.c

6951

static bool is_single_device_io(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6981

static void map_blocks_raid1(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6996

io_geom->stripe_index = find_live_mirror(fs_info, map, 0,

fs/btrfs/volumes.c

7017

static void map_blocks_raid10(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7039

io_geom->stripe_index = find_live_mirror(fs_info, map,

fs/btrfs/volumes.c

7137

int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,

fs/btrfs/volumes.c

7148

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/volumes.c

7160

map = btrfs_get_chunk_map(fs_info, logical, *length);

fs/btrfs/volumes.c

7167

ret = btrfs_translate_remap(fs_info, &new_logical, length);

fs/btrfs/volumes.c

7174

map = btrfs_get_chunk_map(fs_info, new_logical, *length);

fs/btrfs/volumes.c

7192

io_geom.use_rst = btrfs_need_stripe_tree_update(fs_info, map->type);

fs/btrfs/volumes.c

7212

map_blocks_raid1(fs_info, map, &io_geom, dev_replace_is_ongoing);

fs/btrfs/volumes.c

7218

map_blocks_raid10(fs_info, map, &io_geom, dev_replace_is_ongoing);

fs/btrfs/volumes.c

7237

btrfs_crit(fs_info,

fs/btrfs/volumes.c

7261

if (is_single_device_io(fs_info, smap, map, num_alloc_stripes, &io_geom)) {

fs/btrfs/volumes.c

7262

ret = set_io_stripe(fs_info, logical, length, smap, map, &io_geom);

fs/btrfs/volumes.c

7269

bioc = alloc_btrfs_io_context(fs_info, logical, num_alloc_stripes);

fs/btrfs/volumes.c

7314

ret = set_io_stripe(fs_info, logical, length,

fs/btrfs/volumes.c

7456

struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7463

if (WARN_ON(!devid && !fs_info))

fs/btrfs/volumes.c

7476

btrfs_extent_io_tree_init(fs_info, &dev->alloc_state, IO_TREE_DEVICE_ALLOC_STATE);

fs/btrfs/volumes.c

7483

ret = find_next_devid(fs_info, &tmp);

fs/btrfs/volumes.c

7510

static void btrfs_report_missing_device(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7514

btrfs_err_rl(fs_info, "devid %llu uuid %pU is missing",

fs/btrfs/volumes.c

7517

btrfs_warn_rl(fs_info, "devid %llu uuid %pU is missing",

fs/btrfs/volumes.c

7536

static int check_32bit_meta_chunk(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7545

btrfs_err_32bit_limit(fs_info);

fs/btrfs/volumes.c

7555

static void warn_32bit_meta_chunk(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7564

btrfs_warn_32bit_limit(fs_info);

fs/btrfs/volumes.c

7568

static struct btrfs_device *handle_missing_device(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7573

if (!btrfs_test_opt(fs_info, DEGRADED)) {

fs/btrfs/volumes.c

7574

btrfs_report_missing_device(fs_info, devid, uuid, true);

fs/btrfs/volumes.c

7578

dev = add_missing_dev(fs_info->fs_devices, devid, uuid);

fs/btrfs/volumes.c

7580

btrfs_err(fs_info, "failed to init missing device %llu: %ld",

fs/btrfs/volumes.c

7584

btrfs_report_missing_device(fs_info, devid, uuid, false);

fs/btrfs/volumes.c

7593

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/volumes.c

7612

ret = check_32bit_meta_chunk(fs_info, logical, length, type);

fs/btrfs/volumes.c

7615

warn_32bit_meta_chunk(fs_info, logical, length, type);

fs/btrfs/volumes.c

7618

map = btrfs_find_chunk_map(fs_info, logical, 1);

fs/btrfs/volumes.c

7663

map->stripes[i].dev = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

7665

map->stripes[i].dev = handle_missing_device(fs_info,

fs/btrfs/volumes.c

7678

ret = btrfs_add_chunk_map(fs_info, map);

fs/btrfs/volumes.c

7680

btrfs_err(fs_info,

fs/btrfs/volumes.c

7712

static struct btrfs_fs_devices *open_seed_devices(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7722

list_for_each_entry(fs_devices, &fs_info->fs_devices->seed_list, seed_list)

fs/btrfs/volumes.c

7729

if (!btrfs_test_opt(fs_info, DEGRADED)) {

fs/btrfs/volumes.c

7730

btrfs_err(fs_info,

fs/btrfs/volumes.c

7742

list_add(&fs_devices->seed_list, &fs_info->fs_devices->seed_list);

fs/btrfs/volumes.c

7754

ret = open_fs_devices(fs_devices, BLK_OPEN_READ, fs_info->sb);

fs/btrfs/volumes.c

7766

list_add(&fs_devices->seed_list, &fs_info->fs_devices->seed_list);

fs/btrfs/volumes.c

7775

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/volumes.c

7776

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

7792

fs_devices = open_seed_devices(fs_info, fs_uuid);

fs/btrfs/volumes.c

7797

device = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

7799

if (!btrfs_test_opt(fs_info, DEGRADED)) {

fs/btrfs/volumes.c

7800

btrfs_report_missing_device(fs_info, devid,

fs/btrfs/volumes.c

7807

btrfs_err(fs_info,

fs/btrfs/volumes.c

7812

btrfs_report_missing_device(fs_info, devid, dev_uuid, false);

fs/btrfs/volumes.c

7815

if (!btrfs_test_opt(fs_info, DEGRADED)) {

fs/btrfs/volumes.c

7816

btrfs_report_missing_device(fs_info,

fs/btrfs/volumes.c

7820

btrfs_report_missing_device(fs_info, devid,

fs/btrfs/volumes.c

7852

if (device->fs_devices != fs_info->fs_devices) {

fs/btrfs/volumes.c

7864

btrfs_err(fs_info,

fs/btrfs/volumes.c

7876

&fs_info->free_chunk_space);

fs/btrfs/volumes.c

7882

int btrfs_read_sys_array(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

7884

struct btrfs_super_block *super_copy = fs_info->super_copy;

fs/btrfs/volumes.c

7893

ASSERT(BTRFS_SUPER_INFO_SIZE <= fs_info->nodesize);

fs/btrfs/volumes.c

7900

sb = alloc_dummy_extent_buffer(fs_info, BTRFS_SUPER_INFO_OFFSET);

fs/btrfs/volumes.c

7959

bool btrfs_check_rw_degradable(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7966

map = btrfs_find_chunk_map(fs_info, 0, U64_MAX);

fs/btrfs/volumes.c

7991

btrfs_warn(fs_info,

fs/btrfs/volumes.c

8000

map = btrfs_find_chunk_map(fs_info, next_start, U64_MAX - next_start);

fs/btrfs/volumes.c

8015

int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

8017

struct btrfs_root *root = fs_info->chunk_root;

fs/btrfs/volumes.c

8044

fs_info->fs_devices->total_rw_bytes = 0;

fs/btrfs/volumes.c

8056

ASSERT(!test_bit(BTRFS_FS_OPEN, &fs_info->flags));

fs/btrfs/volumes.c

8115

if (total_dev != fs_info->fs_devices->total_devices) {

fs/btrfs/volumes.c

8116

btrfs_warn(fs_info,

fs/btrfs/volumes.c

8118

btrfs_super_num_devices(fs_info->super_copy),

fs/btrfs/volumes.c

8120

fs_info->fs_devices->total_devices = total_dev;

fs/btrfs/volumes.c

8121

btrfs_set_super_num_devices(fs_info->super_copy, total_dev);

fs/btrfs/volumes.c

8123

if (btrfs_super_total_bytes(fs_info->super_copy) <

fs/btrfs/volumes.c

8124

fs_info->fs_devices->total_rw_bytes) {

fs/btrfs/volumes.c

8125

btrfs_err(fs_info,

fs/btrfs/volumes.c

8127

btrfs_super_total_bytes(fs_info->super_copy),

fs/btrfs/volumes.c

8128

fs_info->fs_devices->total_rw_bytes);

fs/btrfs/volumes.c

8138

int btrfs_init_devices_late(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

8140

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;

fs/btrfs/volumes.c

8146

device->fs_info = fs_info;

fs/btrfs/volumes.c

8150

device->fs_info = fs_info;

fs/btrfs/volumes.c

8156

seed_devs->fs_info = fs_info;

fs/btrfs/volumes.c

8195

if (!device->fs_info->dev_root)

fs/btrfs/volumes.c

8201

ret = btrfs_search_slot(NULL, device->fs_info->dev_root, &key, path, 0, 0);

fs/btrfs/volumes.c

8230

int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

8232

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;

fs/btrfs/volumes.c

8259

int btrfs_init_writeback_bio_size(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

8261

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

8263

u32 writeback_bio_size = fs_info->sectorsize;

fs/btrfs/volumes.c

8285

fs_info->writeback_bio_size = writeback_bio_size;

fs/btrfs/volumes.c

8293

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

8294

struct btrfs_root *dev_root = fs_info->dev_root;

fs/btrfs/volumes.c

8311

btrfs_warn(fs_info,

fs/btrfs/volumes.c

8322

btrfs_warn(fs_info,

fs/btrfs/volumes.c

8336

btrfs_warn(fs_info,

fs/btrfs/volumes.c

8356

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

8357

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

8428

btrfs_err_rl(dev->fs_info,

fs/btrfs/volumes.c

8448

btrfs_info(dev->fs_info,

fs/btrfs/volumes.c

8458

int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

8463

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

8468

dev = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

8472

btrfs_warn(fs_info, "get dev_stats failed, device not found");

fs/btrfs/volumes.c

8475

btrfs_warn(fs_info, "get dev_stats failed, not yet valid");

fs/btrfs/volumes.c

8485

btrfs_info(fs_info, "device stats zeroed by %s (%d)",

fs/btrfs/volumes.c

8518

mutex_lock(&trans->fs_info->chunk_mutex);

fs/btrfs/volumes.c

8525

mutex_unlock(&trans->fs_info->chunk_mutex);

fs/btrfs/volumes.c

8538

static int verify_one_dev_extent(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

8550

map = btrfs_find_chunk_map(fs_info, chunk_offset, 1);

fs/btrfs/volumes.c

8552

btrfs_err(fs_info,

fs/btrfs/volumes.c

8561

btrfs_err(fs_info,

fs/btrfs/volumes.c

8575

btrfs_warn(fs_info,

fs/btrfs/volumes.c

8584

btrfs_err(fs_info,

fs/btrfs/volumes.c

8595

btrfs_err(fs_info,

fs/btrfs/volumes.c

8602

dev = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

8604

btrfs_err(fs_info, "failed to find devid %llu", devid);

fs/btrfs/volumes.c

8610

btrfs_err(fs_info,

fs/btrfs/volumes.c

8623

btrfs_err(fs_info,

fs/btrfs/volumes.c

8636

static int verify_chunk_dev_extent_mapping(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

8641

read_lock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

8642

for (node = rb_first_cached(&fs_info->mapping_tree); node; node = rb_next(node)) {

fs/btrfs/volumes.c

8647

btrfs_err(fs_info,

fs/btrfs/volumes.c

8655

read_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

8666

int btrfs_verify_dev_extents(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

8669

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/volumes.c

8685

if (btrfs_test_opt(fs_info, IGNOREBADROOTS))

fs/btrfs/volumes.c

8730

btrfs_err(fs_info,

fs/btrfs/volumes.c

8736

ret = verify_one_dev_extent(fs_info, chunk_offset, devid,

fs/btrfs/volumes.c

8753

ret = verify_chunk_dev_extent_mapping(fs_info);

fs/btrfs/volumes.c

8757

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

8758

btrfs_update_per_profile_avail(fs_info);

fs/btrfs/volumes.c

8759

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

8770

bool btrfs_verify_dev_items(const struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

8777

list_for_each_entry(dev, &fs_info->fs_devices->devices, dev_list) {

fs/btrfs/volumes.c

8784

btrfs_err(fs_info,

fs/btrfs/volumes.c

8790

list_for_each_entry(seed_devs, &fs_info->fs_devices->seed_list, seed_list) {

fs/btrfs/volumes.c

8793

btrfs_err(fs_info,

fs/btrfs/volumes.c

8802

btrfs_err(fs_info,

fs/btrfs/volumes.c

8811

bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr)

fs/btrfs/volumes.c

8816

spin_lock(&fs_info->swapfile_pins_lock);

fs/btrfs/volumes.c

8817

node = fs_info->swapfile_pins.rb_node;

fs/btrfs/volumes.c

8827

spin_unlock(&fs_info->swapfile_pins_lock);

fs/btrfs/volumes.c

8834

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/volumes.c

8841

guard(super_write)(fs_info->sb);

fs/btrfs/volumes.c

8843

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE)) {

fs/btrfs/volumes.c

8844

btrfs_info(fs_info,

fs/btrfs/volumes.c

8850

mutex_lock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

8853

cache = btrfs_lookup_block_group(fs_info, target);

fs/btrfs/volumes.c

8860

ret = btrfs_may_alloc_data_chunk(fs_info, target);

fs/btrfs/volumes.c

8864

btrfs_info(fs_info,

fs/btrfs/volumes.c

8867

ret = btrfs_relocate_chunk(fs_info, target, true);

fs/btrfs/volumes.c

8872

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

8873

btrfs_exclop_finish(fs_info);

fs/btrfs/volumes.c

8878

bool btrfs_repair_one_zone(struct btrfs_fs_info *fs_info, u64 logical)

fs/btrfs/volumes.c

8882

if (!btrfs_is_zoned(fs_info))

fs/btrfs/volumes.c

8886

if (btrfs_test_opt(fs_info, DEGRADED))

fs/btrfs/volumes.c

8889

cache = btrfs_lookup_block_group(fs_info, logical);

fs/btrfs/volumes.c

8939

int btrfs_map_repair_block(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

8950

ret = btrfs_map_block(fs_info, BTRFS_MAP_WRITE, logical, &map_length,

fs/btrfs/volumes.h

127

struct btrfs_fs_info *fs_info;

fs/btrfs/volumes.h

446

struct btrfs_fs_info *fs_info;

fs/btrfs/volumes.h

521

struct btrfs_fs_info *fs_info;

fs/btrfs/volumes.h

726

int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,

fs/btrfs/volumes.h

730

int btrfs_map_repair_block(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

733

struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

736

int btrfs_read_sys_array(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

737

int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

741

void btrfs_mapping_tree_free(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

750

struct btrfs_device *btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

753

int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

756

struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

760

int btrfs_rm_device(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

764

int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);

fs/btrfs/volumes.h

770

int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *path);

fs/btrfs/volumes.h

771

int btrfs_balance(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

775

int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

776

int btrfs_recover_balance(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

777

int btrfs_pause_balance(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

778

int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset,

fs/btrfs/volumes.h

780

int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

781

bool btrfs_chunk_writeable(struct btrfs_fs_info *fs_info, u64 chunk_offset);

fs/btrfs/volumes.h

783

int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

785

int btrfs_init_devices_late(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

786

int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

787

int btrfs_init_writeback_bio_size(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

792

unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

803

int btrfs_add_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map);

fs/btrfs/volumes.h

806

struct btrfs_chunk_map *btrfs_find_chunk_map(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

808

struct btrfs_chunk_map *btrfs_find_chunk_map_nolock(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

810

struct btrfs_chunk_map *btrfs_get_chunk_map(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

812

void btrfs_remove_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map);

fs/btrfs/volumes.h

898

bool btrfs_check_rw_degradable(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

900

void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info, struct btrfs_device *device);

fs/btrfs/volumes.h

905

int btrfs_verify_dev_extents(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

906

bool btrfs_verify_dev_items(const struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

907

void btrfs_update_per_profile_avail(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

909

static inline bool btrfs_get_per_profile_avail(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

913

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.h

921

spin_unlock(&fs_info->fs_devices->per_profile_lock);

fs/btrfs/volumes.h

925

bool btrfs_repair_one_zone(struct btrfs_fs_info *fs_info, u64 logical);

fs/btrfs/volumes.h

927

bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr);

fs/btrfs/volumes.h

939

struct btrfs_io_context *alloc_btrfs_io_context(struct btrfs_fs_info *fs_info,

fs/btrfs/xattr.c

82

if (name_len + size > BTRFS_MAX_XATTR_SIZE(root->fs_info))

fs/btrfs/zlib.c

150

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/zlib.c

156

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/zlib.c

165

btrfs_err(fs_info,

fs/btrfs/zlib.c

175

out_folio = btrfs_alloc_compr_folio(fs_info, GFP_NOFS);

fs/btrfs/zlib.c

200

if (need_special_buffer(fs_info)) {

fs/btrfs/zlib.c

231

btrfs_warn(fs_info,

fs/btrfs/zlib.c

241

if (workspace->strm.total_in > fs_info->sectorsize * 2 &&

fs/btrfs/zlib.c

257

out_folio = btrfs_alloc_compr_folio(fs_info, GFP_NOFS);

fs/btrfs/zlib.c

294

out_folio = btrfs_alloc_compr_folio(fs_info, GFP_NOFS);

fs/btrfs/zlib.c

340

struct btrfs_fs_info *fs_info = cb_to_fs_info(cb);

fs/btrfs/zlib.c

343

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/zlib.c

37

struct list_head *zlib_get_workspace(struct btrfs_fs_info *fs_info, unsigned int level)

fs/btrfs/zlib.c

383

btrfs_err(inode->root->fs_info,

fs/btrfs/zlib.c

39

struct list_head *ws = btrfs_get_workspace(fs_info, BTRFS_COMPRESS_ZLIB, level);

fs/btrfs/zlib.c

426

btrfs_err(cb->bbio.inode->root->fs_info,

fs/btrfs/zlib.c

472

btrfs_err(inode->root->fs_info,

fs/btrfs/zlib.c

494

btrfs_err(inode->root->fs_info,

fs/btrfs/zlib.c

63

static bool need_special_buffer(struct btrfs_fs_info *fs_info)

fs/btrfs/zlib.c

67

if (btrfs_min_folio_size(fs_info) >= ZLIB_DFLTCC_BUF_SIZE)

fs/btrfs/zlib.c

72

struct list_head *zlib_alloc_workspace(struct btrfs_fs_info *fs_info, unsigned int level)

fs/btrfs/zlib.c

86

if (need_special_buffer(fs_info)) {

fs/btrfs/zlib.c

93

workspace->buf = kmalloc(fs_info->sectorsize, GFP_KERNEL);

fs/btrfs/zlib.c

94

workspace->buf_size = fs_info->sectorsize;

fs/btrfs/zoned.c

1224

device->fs_info,

fs/btrfs/zoned.c

1247

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/zoned.c

1279

root = btrfs_extent_root(fs_info, key.objectid);

fs/btrfs/zoned.c

1281

btrfs_err(fs_info,

fs/btrfs/zoned.c

1308

length = fs_info->nodesize;

fs/btrfs/zoned.c

1324

static int btrfs_load_zone_info(struct btrfs_fs_info *fs_info, int zone_idx,

fs/btrfs/zoned.c

1328

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/zoned.c

1370

WARN_ON(!IS_ALIGNED(info->physical, fs_info->zone_size));

fs/btrfs/zoned.c

1395

btrfs_err(fs_info,

fs/btrfs/zoned.c

1408

btrfs_err(fs_info,

fs/btrfs/zoned.c

1437

btrfs_err(bg->fs_info,

fs/btrfs/zoned.c

1456

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.c

1458

if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {

fs/btrfs/zoned.c

1459

btrfs_err(fs_info, "zoned: data DUP profile needs raid-stripe-tree");

fs/btrfs/zoned.c

1466

btrfs_err(fs_info,

fs/btrfs/zoned.c

1472

btrfs_err(fs_info,

fs/btrfs/zoned.c

1499

btrfs_err(fs_info,

fs/btrfs/zoned.c

1521

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.c

1524

if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {

fs/btrfs/zoned.c

1525

btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",

fs/btrfs/zoned.c

1556

!btrfs_test_opt(fs_info, DEGRADED))) {

fs/btrfs/zoned.c

1557

btrfs_err(fs_info,

fs/btrfs/zoned.c

1563

if (unlikely(!btrfs_test_opt(fs_info, DEGRADED) &&

fs/btrfs/zoned.c

1587

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.c

1593

if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {

fs/btrfs/zoned.c

1594

btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",

fs/btrfs/zoned.c

1653

btrfs_err(fs_info,

fs/btrfs/zoned.c

1661

btrfs_err(fs_info,

fs/btrfs/zoned.c

1686

btrfs_err(fs_info, "zoned: stripe gap too large in block group %llu", bg->start);

fs/btrfs/zoned.c

1691

btrfs_err(fs_info, "zoned: allocated extent stays beyond write pointers %llu %llu",

fs/btrfs/zoned.c

1705

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.c

1712

if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {

fs/btrfs/zoned.c

1713

btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",

fs/btrfs/zoned.c

1739

btrfs_err(fs_info,

fs/btrfs/zoned.c

1750

btrfs_err(fs_info,

fs/btrfs/zoned.c

1796

btrfs_err(fs_info,

fs/btrfs/zoned.c

1804

btrfs_err(fs_info,

fs/btrfs/zoned.c

1836

btrfs_err(fs_info, "zoned: stripe gap too large in block group %llu",

fs/btrfs/zoned.c

1842

btrfs_err(fs_info, "zoned: allocated extent stays beyond write pointers %llu %llu",

fs/btrfs/zoned.c

1856

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.c

1882

btrfs_err(fs_info, "zoned: profile %s not yet supported",

fs/btrfs/zoned.c

1908

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/zoned.c

1919

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

1923

if (unlikely(!IS_ALIGNED(length, fs_info->zone_size))) {

fs/btrfs/zoned.c

1924

btrfs_err(fs_info,

fs/btrfs/zoned.c

1926

logical, length, fs_info->zone_size);

fs/btrfs/zoned.c

1930

map = btrfs_find_chunk_map(fs_info, logical, length);

fs/btrfs/zoned.c

1949

ret = btrfs_load_zone_info(fs_info, i, &zone_info[i], active, map, new);

fs/btrfs/zoned.c

1965

btrfs_err(fs_info,

fs/btrfs/zoned.c

1983

!fs_info->stripe_root) {

fs/btrfs/zoned.c

1984

btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",

fs/btrfs/zoned.c

1990

btrfs_err(fs_info,

fs/btrfs/zoned.c

1999

btrfs_err(fs_info,

fs/btrfs/zoned.c

2009

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2011

&fs_info->zone_active_bgs);

fs/btrfs/zoned.c

2012

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2027

if (!btrfs_is_zoned(cache->fs_info))

fs/btrfs/zoned.c

204

const sector_t zone_sectors = device->fs_info->zone_size >> SECTOR_SHIFT;

fs/btrfs/zoned.c

2045

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/zoned.c

2049

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2069

cache = btrfs_lookup_block_group(fs_info, start);

fs/btrfs/zoned.c

2130

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/zoned.c

2164

btrfs_err(fs_info, "failed to split ordered extent");

fs/btrfs/zoned.c

2182

test_bit(BTRFS_FS_STATE_NO_DATA_CSUMS, &fs_info->fs_state)) {

fs/btrfs/zoned.c

2196

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/zoned.c

2201

if (fs_info->treelog_bg == block_group->start) {

fs/btrfs/zoned.c

2205

btrfs_zoned_meta_io_unlock(fs_info);

fs/btrfs/zoned.c

2206

ret_fin = btrfs_zone_finish_one_bg(fs_info);

fs/btrfs/zoned.c

2207

btrfs_zoned_meta_io_lock(fs_info);

fs/btrfs/zoned.c

2216

lockdep_assert_held(&fs_info->zoned_meta_io_lock);

fs/btrfs/zoned.c

2230

btrfs_zoned_meta_io_unlock(fs_info);

fs/btrfs/zoned.c

2233

btrfs_zoned_meta_io_lock(fs_info);

fs/btrfs/zoned.c

2259

int btrfs_check_meta_write_pointer(struct btrfs_fs_info *fs_info,

fs/btrfs/zoned.c

2266

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2279

block_group = btrfs_lookup_block_group(fs_info, eb->start);

fs/btrfs/zoned.c

2288

if (!test_bit(BTRFS_FS_ACTIVE_ZONE_TRACKING, &fs_info->flags))

fs/btrfs/zoned.c

2292

tgt = &fs_info->active_system_bg;

fs/btrfs/zoned.c

2294

tgt = &fs_info->active_meta_bg;

fs/btrfs/zoned.c

2321

static int read_zone_info(struct btrfs_fs_info *fs_info, u64 logical,

fs/btrfs/zoned.c

2330

ret = btrfs_map_block(fs_info, BTRFS_MAP_GET_READ_MIRRORS, logical,

fs/btrfs/zoned.c

2372

struct btrfs_fs_info *fs_info = tgt_dev->fs_info;

fs/btrfs/zoned.c

2381

ret = read_zone_info(fs_info, logical, &zone);

fs/btrfs/zoned.c

2406

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/zoned.c

2414

if (!btrfs_is_zoned(block_group->fs_info))

fs/btrfs/zoned.c

2417

if (unlikely(btrfs_is_testing(fs_info)))

fs/btrfs/zoned.c

2422

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2480

list_add_tail(&block_group->active_bg_list, &fs_info->zone_active_bgs);

fs/btrfs/zoned.c

2481

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2487

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2493

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/zoned.c

2496

unsigned long index, start = (block_group->start >> fs_info->nodesize_bits);

fs/btrfs/zoned.c

2499

xa_for_each_start(&fs_info->buffer_tree, index, eb, start) {

fs/btrfs/zoned.c

2547

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/zoned.c

2551

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/zoned.c

2589

btrfs_wait_ordered_roots(fs_info, U64_MAX, block_group);

fs/btrfs/zoned.c

2641

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2644

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2649

clear_and_wake_up_bit(BTRFS_FS_NEED_ZONE_FINISH, &fs_info->flags);

fs/btrfs/zoned.c

2656

if (!btrfs_is_zoned(block_group->fs_info))

fs/btrfs/zoned.c

2664

struct btrfs_fs_info *fs_info = fs_devices->fs_info;

fs/btrfs/zoned.c

2668

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2671

if (test_bit(BTRFS_FS_NEED_ZONE_FINISH, &fs_info->flags))

fs/btrfs/zoned.c

2675

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/zoned.c

2676

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2703

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2704

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/zoned.c

2707

set_bit(BTRFS_FS_NEED_ZONE_FINISH, &fs_info->flags);

fs/btrfs/zoned.c

2712

int btrfs_zone_finish_endio(struct btrfs_fs_info *fs_info, u64 logical, u64 length)

fs/btrfs/zoned.c

2717

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2720

block_group = btrfs_lookup_block_group(fs_info, logical);

fs/btrfs/zoned.c

2726

min_alloc_bytes = fs_info->sectorsize;

fs/btrfs/zoned.c

2728

min_alloc_bytes = fs_info->nodesize;

fs/btrfs/zoned.c

274

btrfs_err(device->fs_info,

fs/btrfs/zoned.c

2752

btrfs_handle_fs_error(bg->fs_info, ret,

fs/btrfs/zoned.c

2765

btrfs_err(bg->fs_info, "double scheduling of bg %llu zone finishing",

fs/btrfs/zoned.c

2780

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.c

2782

spin_lock(&fs_info->relocation_bg_lock);

fs/btrfs/zoned.c

2783

if (fs_info->data_reloc_bg == bg->start)

fs/btrfs/zoned.c

2784

fs_info->data_reloc_bg = 0;

fs/btrfs/zoned.c

2785

spin_unlock(&fs_info->relocation_bg_lock);

fs/btrfs/zoned.c

2788

void btrfs_zoned_reserve_data_reloc_bg(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

2790

struct btrfs_space_info *data_sinfo = fs_info->data_sinfo;

fs/btrfs/zoned.c

2800

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2803

if (fs_info->data_reloc_bg)

fs/btrfs/zoned.c

2806

if (sb_rdonly(fs_info->sb))

fs/btrfs/zoned.c

2809

alloc_flags = btrfs_get_alloc_profile(fs_info, space_info->flags);

fs/btrfs/zoned.c

2846

btrfs_add_bg_to_space_info(fs_info, bg);

fs/btrfs/zoned.c

2849

fs_info->data_reloc_bg = bg->start;

fs/btrfs/zoned.c

2859

trans = btrfs_join_transaction(fs_info->tree_root);

fs/btrfs/zoned.c

2879

void btrfs_free_zone_cache(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

2881

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/zoned.c

2884

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2897

bool btrfs_zoned_should_reclaim(const struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

2899

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/zoned.c

2901

u64 total = btrfs_super_total_bytes(fs_info->super_copy);

fs/btrfs/zoned.c

2905

ASSERT(btrfs_is_zoned(fs_info));

fs/btrfs/zoned.c

2907

if (fs_info->bg_reclaim_threshold == 0)

fs/btrfs/zoned.c

2920

return factor >= fs_info->bg_reclaim_threshold;

fs/btrfs/zoned.c

2923

void btrfs_zoned_release_data_reloc_bg(struct btrfs_fs_info *fs_info, u64 logical,

fs/btrfs/zoned.c

2928

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2931

block_group = btrfs_lookup_block_group(fs_info, logical);

fs/btrfs/zoned.c

2954

int btrfs_zone_finish_one_bg(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

296

static int calculate_emulated_zone_size(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

2961

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2962

list_for_each_entry(block_group, &fs_info->zone_active_bgs,

fs/btrfs/zoned.c

2984

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

299

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/zoned.c

2997

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/zoned.c

3001

if (!btrfs_is_zoned(fs_info) || (space_info->flags & BTRFS_BLOCK_GROUP_DATA))

fs/btrfs/zoned.c

3035

ret = btrfs_zone_finish_one_bg(fs_info);

fs/btrfs/zoned.c

3049

void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

3051

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/zoned.c

3059

if (!test_bit(BTRFS_FS_ACTIVE_ZONE_TRACKING, &fs_info->flags))

fs/btrfs/zoned.c

3066

if (fs_info->avail_metadata_alloc_bits & BTRFS_BLOCK_GROUP_DUP)

fs/btrfs/zoned.c

3068

if (fs_info->avail_system_alloc_bits & BTRFS_BLOCK_GROUP_DUP)

fs/btrfs/zoned.c

3083

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

3084

list_for_each_entry(block_group, &fs_info->zone_active_bgs, active_bg_list) {

fs/btrfs/zoned.c

3094

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

3114

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/zoned.c

3115

const sector_t zone_size_sectors = fs_info->zone_size >> SECTOR_SHIFT;

fs/btrfs/zoned.c

3117

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

3134

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/zoned.c

3135

list_for_each_entry(bg, &fs_info->unused_bgs, bg_list) {

fs/btrfs/zoned.c

3156

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/zoned.c

3162

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/zoned.c

3170

down_read(&fs_info->dev_replace.rwsem);

fs/btrfs/zoned.c

3184

up_read(&fs_info->dev_replace.rwsem);

fs/btrfs/zoned.c

3188

up_read(&fs_info->dev_replace.rwsem);

fs/btrfs/zoned.c

3233

void btrfs_show_zoned_stats(struct btrfs_fs_info *fs_info, struct seq_file *seq)

fs/btrfs/zoned.c

3241

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

3243

list_count_nodes(&fs_info->zone_active_bgs));

fs/btrfs/zoned.c

3244

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

3246

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/zoned.c

3248

list_count_nodes(&fs_info->reclaim_bgs));

fs/btrfs/zoned.c

3249

seq_printf(seq, "\t unused: %zu\n", list_count_nodes(&fs_info->unused_bgs));

fs/btrfs/zoned.c

3250

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/zoned.c

3253

str_true_false(btrfs_zoned_should_reclaim(fs_info)));

fs/btrfs/zoned.c

3255

data_reloc_bg = data_race(fs_info->data_reloc_bg);

fs/btrfs/zoned.c

3259

treelog_bg = data_race(fs_info->treelog_bg);

fs/btrfs/zoned.c

3263

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

3265

list_for_each_entry(bg, &fs_info->zone_active_bgs, active_bg_list) {

fs/btrfs/zoned.c

328

fs_info->zone_size = btrfs_dev_extent_length(leaf, dext);

fs/btrfs/zoned.c

3285

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

332

int btrfs_get_dev_zone_info_all_devices(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

334

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/zoned.c

339

if (!btrfs_fs_incompat(fs_info, ZONED))

fs/btrfs/zoned.c

366

btrfs_err(device->fs_info, "zoned: not enough zones to mount filesystem: %u < %d",

fs/btrfs/zoned.c

383

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/zoned.c

399

if (!btrfs_fs_incompat(fs_info, ZONED))

fs/btrfs/zoned.c

412

if (!fs_info->zone_size) {

fs/btrfs/zoned.c

413

ret = calculate_emulated_zone_size(fs_info);

fs/btrfs/zoned.c

418

ASSERT(fs_info->zone_size);

fs/btrfs/zoned.c

419

zone_sectors = fs_info->zone_size >> SECTOR_SHIFT;

fs/btrfs/zoned.c

429

btrfs_err(fs_info,

fs/btrfs/zoned.c

436

btrfs_err(fs_info,

fs/btrfs/zoned.c

487

btrfs_err(device->fs_info,

fs/btrfs/zoned.c

525

btrfs_err(device->fs_info,

fs/btrfs/zoned.c

535

btrfs_err(device->fs_info,

fs/btrfs/zoned.c

553

set_bit(BTRFS_FS_ACTIVE_ZONE_TRACKING, &fs_info->flags);

fs/btrfs/zoned.c

575

btrfs_err(device->fs_info,

fs/btrfs/zoned.c

593

btrfs_err(device->fs_info,

fs/btrfs/zoned.c

612

btrfs_info(fs_info,

fs/btrfs/zoned.c

692

static int btrfs_check_for_zoned_device(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

696

list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) {

fs/btrfs/zoned.c

698

btrfs_err(fs_info,

fs/btrfs/zoned.c

708

int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

710

struct queue_limits *lim = &fs_info->limits;

fs/btrfs/zoned.c

719

if (!btrfs_fs_incompat(fs_info, ZONED))

fs/btrfs/zoned.c

720

return btrfs_check_for_zoned_device(fs_info);

fs/btrfs/zoned.c

724

list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) {

fs/btrfs/zoned.c

733

btrfs_err(fs_info,

fs/btrfs/zoned.c

750

btrfs_err(fs_info, "zoned: failed to validate queue limits");

fs/btrfs/zoned.c

760

btrfs_err(fs_info,

fs/btrfs/zoned.c

766

if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {

fs/btrfs/zoned.c

767

btrfs_err(fs_info, "zoned: mixed block groups not supported");

fs/btrfs/zoned.c

771

fs_info->zone_size = zone_size;

fs/btrfs/zoned.c

779

fs_info->max_zone_append_size = ALIGN_DOWN(

fs/btrfs/zoned.c

783

fs_info->sectorsize);

fs/btrfs/zoned.c

784

fs_info->fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_ZONED;

fs/btrfs/zoned.c

786

fs_info->max_extent_size = min_not_zero(fs_info->max_extent_size,

fs/btrfs/zoned.c

787

fs_info->max_zone_append_size);

fs/btrfs/zoned.c

793

ret = btrfs_check_mountopts_zoned(fs_info, &fs_info->mount_opt);

fs/btrfs/zoned.c

797

btrfs_info(fs_info, "zoned mode enabled with zone size %llu", zone_size);

fs/btrfs/zoned.h

100

void btrfs_show_zoned_stats(struct btrfs_fs_info *fs_info, struct seq_file *seq);

fs/btrfs/zoned.h

113

static inline int btrfs_get_dev_zone_info_all_devices(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.h

136

static inline int btrfs_check_zoned_mode(const struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.h

138

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.h

141

btrfs_err(fs_info, "zoned block devices support is not enabled");

fs/btrfs/zoned.h

212

static inline int btrfs_check_meta_write_pointer(struct btrfs_fs_info *fs_info,

fs/btrfs/zoned.h

247

static inline int btrfs_zone_finish_endio(struct btrfs_fs_info *fs_info,

fs/btrfs/zoned.h

258

static inline void btrfs_zoned_reserve_data_reloc_bg(struct btrfs_fs_info *fs_info) { }

fs/btrfs/zoned.h

260

static inline void btrfs_free_zone_cache(struct btrfs_fs_info *fs_info) { }

fs/btrfs/zoned.h

262

static inline bool btrfs_zoned_should_reclaim(const struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.h

267

static inline void btrfs_zoned_release_data_reloc_bg(struct btrfs_fs_info *fs_info,

fs/btrfs/zoned.h

270

static inline int btrfs_zone_finish_one_bg(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.h

282

static inline void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info) { }

fs/btrfs/zoned.h

290

static inline int btrfs_show_zoned_stats(struct btrfs_fs_info *fs_info, struct seq_file *seq)

fs/btrfs/zoned.h

343

static inline bool btrfs_check_device_zone_type(const struct btrfs_fs_info *fs_info,

fs/btrfs/zoned.h

346

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/zoned.h

354

return fs_info->zone_size ==

fs/btrfs/zoned.h

386

static inline void btrfs_zoned_meta_io_lock(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.h

388

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.h

390

mutex_lock(&fs_info->zoned_meta_io_lock);

fs/btrfs/zoned.h

393

static inline void btrfs_zoned_meta_io_unlock(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.h

395

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.h

397

mutex_unlock(&fs_info->zoned_meta_io_lock);

fs/btrfs/zoned.h

402

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.h

404

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.h

407

spin_lock(&fs_info->treelog_bg_lock);

fs/btrfs/zoned.h

408

if (fs_info->treelog_bg == bg->start)

fs/btrfs/zoned.h

409

fs_info->treelog_bg = 0;

fs/btrfs/zoned.h

410

spin_unlock(&fs_info->treelog_bg_lock);

fs/btrfs/zoned.h

417

if (btrfs_is_data_reloc_root(root) && btrfs_is_zoned(root->fs_info))

fs/btrfs/zoned.h

418

mutex_lock(&root->fs_info->zoned_data_reloc_io_lock);

fs/btrfs/zoned.h

425

if (btrfs_is_data_reloc_root(root) && btrfs_is_zoned(root->fs_info))

fs/btrfs/zoned.h

426

mutex_unlock(&root->fs_info->zoned_data_reloc_io_lock);

fs/btrfs/zoned.h

431

ASSERT(btrfs_is_zoned(bg->fs_info));

fs/btrfs/zoned.h

56

int btrfs_get_dev_zone_info_all_devices(struct btrfs_fs_info *fs_info);

fs/btrfs/zoned.h

60

int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info);

fs/btrfs/zoned.h

78

int btrfs_check_meta_write_pointer(struct btrfs_fs_info *fs_info,

fs/btrfs/zoned.h

86

int btrfs_zone_finish_endio(struct btrfs_fs_info *fs_info, u64 logical,

fs/btrfs/zoned.h

91

void btrfs_zoned_reserve_data_reloc_bg(struct btrfs_fs_info *fs_info);

fs/btrfs/zoned.h

92

void btrfs_free_zone_cache(struct btrfs_fs_info *fs_info);

fs/btrfs/zoned.h

93

bool btrfs_zoned_should_reclaim(const struct btrfs_fs_info *fs_info);

fs/btrfs/zoned.h

94

void btrfs_zoned_release_data_reloc_bg(struct btrfs_fs_info *fs_info, u64 logical,

fs/btrfs/zoned.h

96

int btrfs_zone_finish_one_bg(struct btrfs_fs_info *fs_info);

fs/btrfs/zoned.h

98

void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info);

fs/btrfs/zstd.c

182

int zstd_alloc_workspace_manager(struct btrfs_fs_info *fs_info)

fs/btrfs/zstd.c

187

ASSERT(fs_info->compr_wsm[BTRFS_COMPRESS_ZSTD] == NULL);

fs/btrfs/zstd.c

199

fs_info->compr_wsm[BTRFS_COMPRESS_ZSTD] = zwsm;

fs/btrfs/zstd.c

201

ws = zstd_alloc_workspace(fs_info, ZSTD_BTRFS_MAX_LEVEL);

fs/btrfs/zstd.c

211

void zstd_free_workspace_manager(struct btrfs_fs_info *fs_info)

fs/btrfs/zstd.c

213

struct zstd_workspace_manager *zwsm = fs_info->compr_wsm[BTRFS_COMPRESS_ZSTD];

fs/btrfs/zstd.c

218

fs_info->compr_wsm[BTRFS_COMPRESS_ZSTD] = NULL;

fs/btrfs/zstd.c

246

static struct list_head *zstd_find_workspace(struct btrfs_fs_info *fs_info, int level)

fs/btrfs/zstd.c

248

struct zstd_workspace_manager *zwsm = fs_info->compr_wsm[BTRFS_COMPRESS_ZSTD];

fs/btrfs/zstd.c

285

struct list_head *zstd_get_workspace(struct btrfs_fs_info *fs_info, int level)

fs/btrfs/zstd.c

287

struct zstd_workspace_manager *zwsm = fs_info->compr_wsm[BTRFS_COMPRESS_ZSTD];

fs/btrfs/zstd.c

298

ws = zstd_find_workspace(fs_info, level);

fs/btrfs/zstd.c

303

ws = zstd_alloc_workspace(fs_info, level);

fs/btrfs/zstd.c

330

void zstd_put_workspace(struct btrfs_fs_info *fs_info, struct list_head *ws)

fs/btrfs/zstd.c

332

struct zstd_workspace_manager *zwsm = fs_info->compr_wsm[BTRFS_COMPRESS_ZSTD];

fs/btrfs/zstd.c

371

struct list_head *zstd_alloc_workspace(struct btrfs_fs_info *fs_info, int level)

fs/btrfs/zstd.c

385

workspace->buf = kmalloc(fs_info->sectorsize, GFP_KERNEL);

fs/btrfs/zstd.c

401

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/zstd.c

416

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/zstd.c

423

btrfs_err(fs_info,

fs/btrfs/zstd.c

440

out_folio = btrfs_alloc_compr_folio(fs_info, GFP_NOFS);

fs/btrfs/zstd.c

454

btrfs_warn(fs_info,

fs/btrfs/zstd.c

464

if (tot_in + workspace->in_buf.pos > fs_info->sectorsize * 2 &&

fs/btrfs/zstd.c

483

out_folio = btrfs_alloc_compr_folio(fs_info, GFP_NOFS);

fs/btrfs/zstd.c

525

btrfs_err(fs_info,

fs/btrfs/zstd.c

556

out_folio = btrfs_alloc_compr_folio(fs_info, GFP_NOFS);

fs/btrfs/zstd.c

585

struct btrfs_fs_info *fs_info = cb_to_fs_info(cb);

fs/btrfs/zstd.c

591

const unsigned int min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/zstd.c

607

btrfs_err(inode->root->fs_info,

fs/btrfs/zstd.c

620

workspace->out_buf.size = fs_info->sectorsize;

fs/btrfs/zstd.c

630

btrfs_err(inode->root->fs_info,

fs/btrfs/zstd.c

681

struct btrfs_fs_info *fs_info = btrfs_sb(folio_inode(dest_folio)->i_sb);

fs/btrfs/zstd.c

691

btrfs_err(inode->root->fs_info,

fs/btrfs/zstd.c

705

workspace->out_buf.size = fs_info->sectorsize;

fs/btrfs/zstd.c

715

btrfs_err(inode->root->fs_info,

fs/ext2/xattr_security.c

32

void *fs_info)

fs/ext4/xattr_security.c

37

void *fs_info)

fs/ext4/xattr_security.c

40

handle_t *handle = fs_info;

fs/gfs2/bmap.c

2311

fs_info(sdp, "journal %d mapped with %u extents in %lldms\n", jd->jd_jid,

fs/gfs2/inode.c

665

void *fs_info)

fs/gfs2/lock_dlm.c

1003

fs_info(sdp, "control_mount wait2 block %u start %u mount %u "

fs/gfs2/lock_dlm.c

1012

fs_info(sdp, "control_mount wait3 block %u start %u mount %u "

fs/gfs2/lock_dlm.c

1063

fs_info(sdp, "control_first_done wait gen %u\n", start_gen);

fs/gfs2/lock_dlm.c

1204

fs_info(sdp, "recover_slot jid %d gen %u prev %u\n",

fs/gfs2/lock_dlm.c

1274

fs_info(sdp, "recover jid %d result %s\n", jid,

fs/gfs2/lock_dlm.c

1329

fs_info(sdp, "no fsname found\n");

fs/gfs2/lock_dlm.c

1357

fs_info(sdp, "dlm lockspace ops not used\n");

fs/gfs2/lock_dlm.c

717

fs_info(sdp, "recover generation %u block1 %u %u\n",

fs/gfs2/lock_dlm.c

804

fs_info(sdp, "recover generation %u jid %d\n",

fs/gfs2/lock_dlm.c

824

fs_info(sdp, "recover generation %u done\n", start_gen);

fs/gfs2/lock_dlm.c

827

fs_info(sdp, "recover generation %u block2 %u %u\n",

fs/gfs2/lock_dlm.c

957

fs_info(sdp, "first mounter control generation %u\n", lvb_gen);

fs/gfs2/lock_dlm.c

973

fs_info(sdp, "control_mount wait for journal recovery\n");

fs/gfs2/lock_dlm.c

986

fs_info(sdp, "Recovery is required. Waiting for a "

fs/gfs2/lock_dlm.c

991

fs_info(sdp, "control_mount wait1 block %u start %u "

fs/gfs2/lops.c

1064

fs_info(sdp, "jid=%u: Replayed %u of %u data blocks\n",

fs/gfs2/lops.c

763

fs_info(sdp, obsolete_rgrp_replay, (unsigned long long)blkno,

fs/gfs2/lops.c

765

fs_info(sdp, obsolete_rgrp_replay2,

fs/gfs2/lops.c

843

fs_info(sdp, "jid=%u: Replayed %u of %u blocks\n",

fs/gfs2/lops.c

977

fs_info(sdp, "jid=%u: Found %u revoke tags\n",

fs/gfs2/ops_fstype.c

1015

fs_info(sdp, "unknown hostdata (%s)\n", o);

fs/gfs2/ops_fstype.c

1021

fs_info(sdp, "Now mounting FS (format %u)...\n", sdp->sd_sb.sb_fs_format);

fs/gfs2/ops_fstype.c

1027

fs_info(sdp, "Joined cluster. Now mounting FS (format %u)...\n",

fs/gfs2/ops_fstype.c

517

fs_info(sdp, "first mount done, others may mount\n");

fs/gfs2/ops_fstype.c

981

fs_info(sdp, "Trying to join cluster \"%s\", \"%s\"\n", proto, table);

fs/gfs2/quota.c

1216

fs_info(sdp, "quota %s for %s %u\n",

fs/gfs2/quota.c

1513

fs_info(sdp, "found %u quota changes\n", found);

fs/gfs2/recovery.c

330

fs_info(sdp, "jid=%u: Updated master statfs Total:%lld, "

fs/gfs2/recovery.c

420

fs_info(sdp, "jid=%u: Trying to acquire journal glock...\n",

fs/gfs2/recovery.c

435

fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid);

fs/gfs2/recovery.c

449

fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid);

fs/gfs2/recovery.c

453

fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid);

fs/gfs2/recovery.c

463

fs_info(sdp, "jid=%u: Journal head lookup took %lldms\n", jd->jd_jid,

fs/gfs2/recovery.c

486

fs_info(sdp, "recovery required on "

fs/gfs2/recovery.c

488

fs_info(sdp, "write access will be "

fs/gfs2/recovery.c

502

fs_info(sdp, "jid=%u: Replaying journal...0x%x to 0x%x\n",

fs/gfs2/recovery.c

526

fs_info(sdp, "jid=%u: Journal replayed in %lldms [jlck:%lldms, "

fs/gfs2/recovery.c

545

fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);

fs/gfs2/recovery.c

557

fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done");

fs/gfs2/super.c

682

fs_info(sdp, "GFS2: couldn't thaw filesystem: %d\n", error);

fs/gfs2/super.c

713

fs_info(sdp, "GFS2: couldn't freeze filesystem: %d\n", error);

fs/gfs2/super.c

744

fs_info(sdp, "GFS2: couldn't freeze filesystem: %d\n",

fs/gfs2/sys.c

330

fs_info(sdp, "demote interface used\n");

fs/gfs2/trans.c

300

fs_info(sdp, "GFS2:adding buf while withdrawn! 0x%llx\n",

fs/gfs2/trans.c

305

fs_info(sdp, "GFS2:adding buf while frozen\n");

fs/hfsplus/xattr_security.c

38

void *fs_info)

fs/jffs2/security.c

27

const struct xattr *xattr_array, void *fs_info)

fs/jfs/xattr.c

1023

void *fs_info)

fs/jfs/xattr.c

1026

tid_t *tid = fs_info;

fs/ocfs2/xattr.c

7304

void *fs_info)

fs/ocfs2/xattr.c

7306

struct ocfs2_security_xattr_info *si = fs_info;

fs/proc/base.c

2001

struct proc_fs_info *fs_info = proc_sb_info(inode->i_sb);

fs/proc/base.c

2011

if (!has_pid_permissions(fs_info, task, HIDEPID_INVISIBLE)) {

fs/proc/base.c

3478

struct proc_fs_info *fs_info;

fs/proc/base.c

3486

fs_info = proc_sb_info(dentry->d_sb);

fs/proc/base.c

3487

ns = fs_info->pid_ns;

fs/proc/base.c

3497

if (fs_info->hide_pid == HIDEPID_NOT_PTRACEABLE) {

fs/proc/base.c

3498

if (!has_pid_permissions(fs_info, task, HIDEPID_NO_ACCESS))

fs/proc/base.c

3559

struct proc_fs_info *fs_info = proc_sb_info(file_inode(file)->i_sb);

fs/proc/base.c

3583

if (!has_pid_permissions(fs_info, iter.task, HIDEPID_INVISIBLE))

fs/proc/base.c

3790

struct proc_fs_info *fs_info;

fs/proc/base.c

3801

fs_info = proc_sb_info(dentry->d_sb);

fs/proc/base.c

3802

ns = fs_info->pid_ns;

fs/proc/base.c

726

static bool has_pid_permissions(struct proc_fs_info *fs_info,

fs/proc/base.c

735

if (fs_info->hide_pid == HIDEPID_NOT_PTRACEABLE)

fs/proc/base.c

738

if (fs_info->hide_pid < hide_pid_min)

fs/proc/base.c

740

if (in_group_p(fs_info->pid_gid))

fs/proc/base.c

749

struct proc_fs_info *fs_info = proc_sb_info(inode->i_sb);

fs/proc/base.c

756

has_perms = has_pid_permissions(fs_info, task, HIDEPID_NO_ACCESS);

fs/proc/base.c

760

if (fs_info->hide_pid == HIDEPID_INVISIBLE) {

fs/proc/generic.c

272

struct proc_fs_info *fs_info = proc_sb_info(dir->i_sb);

fs/proc/generic.c

274

if (fs_info->pidonly == PROC_PIDONLY_ON)

fs/proc/generic.c

333

struct proc_fs_info *fs_info = proc_sb_info(inode->i_sb);

fs/proc/generic.c

335

if (fs_info->pidonly == PROC_PIDONLY_ON)

fs/proc/inode.c

175

struct proc_fs_info *fs_info = proc_sb_info(root->d_sb);

fs/proc/inode.c

177

if (!gid_eq(fs_info->pid_gid, GLOBAL_ROOT_GID))

fs/proc/inode.c

178

seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, fs_info->pid_gid));

fs/proc/inode.c

179

if (fs_info->hide_pid != HIDEPID_OFF)

fs/proc/inode.c

180

seq_printf(seq, ",hidepid=%s", hidepid2str(fs_info->hide_pid));

fs/proc/inode.c

181

if (fs_info->pidonly != PROC_PIDONLY_OFF)

fs/proc/proc_net.c

274

struct proc_fs_info *fs_info = proc_sb_info(dir->i_sb);

fs/proc/proc_net.c

287

if (net && (fs_info->pidonly == PROC_PIDONLY_ON) &&

fs/proc/proc_net.c

288

security_capable(fs_info->mounter_cred, net->user_ns, CAP_NET_ADMIN, CAP_OPT_NONE) < 0) {

fs/proc/root.c

226

static int proc_apply_options(struct proc_fs_info *fs_info,

fs/proc/root.c

234

ctx->pidonly != fs_info->pidonly)

fs/proc/root.c

238

fs_info->pid_gid = make_kgid(user_ns, ctx->gid);

fs/proc/root.c

240

fs_info->hide_pid = ctx->hidepid;

fs/proc/root.c

242

fs_info->pidonly = ctx->pidonly;

fs/proc/root.c

245

put_pid_ns(fs_info->pid_ns);

fs/proc/root.c

246

fs_info->pid_ns = get_pid_ns(ctx->pid_ns);

fs/proc/root.c

255

struct proc_fs_info *fs_info;

fs/proc/root.c

258

fs_info = kzalloc_obj(*fs_info);

fs/proc/root.c

259

if (!fs_info)

fs/proc/root.c

262

fs_info->pid_ns = get_pid_ns(ctx->pid_ns);

fs/proc/root.c

263

fs_info->mounter_cred = get_cred(fc->cred);

fs/proc/root.c

264

ret = proc_apply_options(fs_info, fc, current_user_ns());

fs/proc/root.c

276

s->s_fs_info = fs_info;

fs/proc/root.c

278

if (fs_info->pidonly == PROC_PIDONLY_ON)

fs/proc/root.c

314

struct proc_fs_info *fs_info = proc_sb_info(sb);

fs/proc/root.c

318

return proc_apply_options(fs_info, fc, current_user_ns());

fs/proc/root.c

359

struct proc_fs_info *fs_info = proc_sb_info(sb);

fs/proc/root.c

362

if (fs_info) {

fs/proc/root.c

363

put_pid_ns(fs_info->pid_ns);

fs/proc/root.c

364

put_cred(fs_info->mounter_cred);

fs/proc/root.c

365

kfree_rcu(fs_info, rcu);

fs/ubifs/xattr.c

606

void *fs_info)

fs/xfs/xfs_iops.c

57

void *fs_info)

include/trace/events/btrfs.h

1050

TP_fast_assign_fsid(inode->root->fs_info);

include/trace/events/btrfs.h

1086

TP_fast_assign_fsid(inode->root->fs_info);

include/trace/events/btrfs.h

1113

TP_fast_assign_fsid(inode->root->fs_info);

include/trace/events/btrfs.h

1140

TP_fast_assign_fsid(inode->root->fs_info);

include/trace/events/btrfs.h

1168

TP_fast_assign_fsid(inode->root->fs_info);

include/trace/events/btrfs.h

1194

TP_fast_assign_fsid(inode->root->fs_info);

include/trace/events/btrfs.h

1221

TP_fast_assign_fsid(inode->root->fs_info);

include/trace/events/btrfs.h

1250

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1283

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1313

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1340

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1366

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1393

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1423

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1450

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1475

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1505

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1539

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1573

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1620

TP_fast_assign_fsid(trans->fs_info);

include/trace/events/btrfs.h

1639

TP_PROTO(const struct btrfs_fs_info *fs_info, int wait),

include/trace/events/btrfs.h

1641

TP_ARGS(fs_info, wait),

include/trace/events/btrfs.h

1647

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1656

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1659

TP_ARGS(fs_info, block_group, create),

include/trace/events/btrfs.h

1670

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1701

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1704

TP_ARGS(fs_info, ref),

include/trace/events/btrfs.h

1717

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1742

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1745

TP_ARGS(fs_info, ref)

include/trace/events/btrfs.h

1750

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1753

TP_ARGS(fs_info, ref)

include/trace/events/btrfs.h

1758

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1761

TP_ARGS(fs_info, ref),

include/trace/events/btrfs.h

1775

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1803

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1806

TP_ARGS(fs_info, ref)

include/trace/events/btrfs.h

1811

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1814

TP_ARGS(fs_info, ref)

include/trace/events/btrfs.h

1819

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1823

TP_ARGS(fs_info, head_ref, action),

include/trace/events/btrfs.h

1832

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1848

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1852

TP_ARGS(fs_info, head_ref, action)

include/trace/events/btrfs.h

1857

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1861

TP_ARGS(fs_info, head_ref, action)

include/trace/events/btrfs.h

1878

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1881

TP_ARGS(fs_info, map, offset, size),

include/trace/events/btrfs.h

1892

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1898

__entry->root_objectid = btrfs_root_id(fs_info->chunk_root);

include/trace/events/btrfs.h

191

#define TP_fast_assign_fsid(fs_info) \

include/trace/events/btrfs.h

1912

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1915

TP_ARGS(fs_info, map, offset, size)

include/trace/events/btrfs.h

1920

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1923

TP_ARGS(fs_info, map, offset, size)

include/trace/events/btrfs.h

193

if (fs_info) \

include/trace/events/btrfs.h

194

memcpy(__entry->fsid, fs_info->fs_devices->fsid, \

include/trace/events/btrfs.h

1942

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

1974

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

1987

TP_PROTO(const struct btrfs_fs_info *fs_info, const char *type, u64 val,

include/trace/events/btrfs.h

1990

TP_ARGS(fs_info, type, val, bytes, reserve),

include/trace/events/btrfs.h

1999

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2013

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 bytes,

include/trace/events/btrfs.h

2016

TP_ARGS(fs_info, flags, bytes, flush, reason),

include/trace/events/btrfs.h

2025

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

204

#define TP_fast_assign_btrfs(fs_info, args...) \

include/trace/events/btrfs.h

2044

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 num_bytes,

include/trace/events/btrfs.h

2047

TP_ARGS(fs_info, flags, num_bytes, state, ret, for_preempt),

include/trace/events/btrfs.h

2057

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

206

TP_fast_assign_fsid(fs_info); \

include/trace/events/btrfs.h

2076

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),

include/trace/events/btrfs.h

2078

TP_ARGS(fs_info, start, len),

include/trace/events/btrfs.h

2085

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2098

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),

include/trace/events/btrfs.h

2100

TP_ARGS(fs_info, start, len)

include/trace/events/btrfs.h

2105

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),

include/trace/events/btrfs.h

2107

TP_ARGS(fs_info, start, len)

include/trace/events/btrfs.h

2124

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

2153

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

2187

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

221

TP_fast_assign_btrfs(trans->fs_info,

include/trace/events/btrfs.h

2227

TP_fast_assign_btrfs(block_group->fs_info,

include/trace/events/btrfs.h

2280

TP_fast_assign_btrfs(block_group->fs_info,

include/trace/events/btrfs.h

2307

TP_fast_assign_btrfs(block_group->fs_info,

include/trace/events/btrfs.h

2331

TP_fast_assign_btrfs(block_group->fs_info,

include/trace/events/btrfs.h

240

TP_fast_assign_btrfs(trans->fs_info,

include/trace/events/btrfs.h

2426

TP_PROTO(const struct btrfs_fs_info *fs_info, const void *wtag),

include/trace/events/btrfs.h

2428

TP_ARGS(fs_info, wtag),

include/trace/events/btrfs.h

2434

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2457

TP_PROTO(const struct btrfs_fs_info *fs_info, const void *wtag),

include/trace/events/btrfs.h

2459

TP_ARGS(fs_info, wtag)

include/trace/events/btrfs.h

2575

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2579

TP_ARGS(fs_info, rec, bytenr),

include/trace/events/btrfs.h

2586

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2597

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2601

TP_ARGS(fs_info, rec, bytenr)

include/trace/events/btrfs.h

2606

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2610

TP_ARGS(fs_info, rec, bytenr)

include/trace/events/btrfs.h

2615

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 transid,

include/trace/events/btrfs.h

2618

TP_ARGS(fs_info, transid, num_dirty_extents),

include/trace/events/btrfs.h

2625

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

263

TP_fast_assign_btrfs(trans->fs_info,

include/trace/events/btrfs.h

2636

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 transid, u64 bytenr,

include/trace/events/btrfs.h

2639

TP_ARGS(fs_info, transid, bytenr, num_bytes, nr_old_roots,

include/trace/events/btrfs.h

2650

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2669

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2673

TP_ARGS(fs_info, qgroup, cur_old_count, cur_new_count),

include/trace/events/btrfs.h

2683

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2698

TP_PROTO(const struct btrfs_fs_info *fs_info, const struct btrfs_qgroup *qgroup,

include/trace/events/btrfs.h

2701

TP_ARGS(fs_info, qgroup, diff, type),

include/trace/events/btrfs.h

2710

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2734

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

2756

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

2780

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

2794

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2797

TP_ARGS(fs_info, oldref, newref, tree_size),

include/trace/events/btrfs.h

2812

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2837

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2840

TP_ARGS(fs_info, oldref, newref, tree_size)

include/trace/events/btrfs.h

2844

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2847

TP_ARGS(fs_info, oldref, newref, tree_size)

include/trace/events/btrfs.h

2862

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

2886

TP_fast_assign_btrfs(bg_cache->fs_info,

include/trace/events/btrfs.h

3031

TP_PROTO(struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

3034

TP_ARGS(fs_info, sinfo),

include/trace/events/btrfs.h

3055

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

3065

__entry->global_reserved = fs_info->global_block_rsv.reserved;

include/trace/events/btrfs.h

3066

__entry->trans_reserved = fs_info->trans_block_rsv.reserved;

include/trace/events/btrfs.h

3067

__entry->delayed_refs_reserved = fs_info->delayed_refs_rsv.reserved;

include/trace/events/btrfs.h

3068

__entry->delayed_reserved = fs_info->delayed_block_rsv.reserved;

include/trace/events/btrfs.h

3069

__entry->free_chunk_space = atomic64_read(&fs_info->free_chunk_space);

include/trace/events/btrfs.h

3070

__entry->delalloc_bytes = percpu_counter_sum_positive(&fs_info->delalloc_bytes);

include/trace/events/btrfs.h

3071

__entry->ordered_bytes = percpu_counter_sum_positive(&fs_info->ordered_bytes);

include/trace/events/btrfs.h

3093

TP_PROTO(struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

3095

TP_ARGS(fs_info, sinfo)

include/trace/events/btrfs.h

3099

TP_PROTO(struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

3101

TP_ARGS(fs_info, sinfo)

include/trace/events/btrfs.h

3105

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 bytes,

include/trace/events/btrfs.h

3108

TP_ARGS(fs_info, flags, bytes, start_ns, flush, error),

include/trace/events/btrfs.h

3118

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

3148

TP_fast_assign_btrfs(eb->fs_info,

include/trace/events/btrfs.h

3189

TP_fast_assign_btrfs(eb->fs_info,

include/trace/events/btrfs.h

3214

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

3217

TP_ARGS(fs_info, sinfo, old, diff),

include/trace/events/btrfs.h

3225

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

3237

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

3240

TP_ARGS(fs_info, sinfo, old, diff)

include/trace/events/btrfs.h

3245

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

3248

TP_ARGS(fs_info, sinfo, old, diff)

include/trace/events/btrfs.h

3253

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

3256

TP_ARGS(fs_info, sinfo, old, diff)

include/trace/events/btrfs.h

3280

TP_fast_assign_btrfs(rbio->bioc->fs_info,

include/trace/events/btrfs.h

3328

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 logical, u64 length,

include/trace/events/btrfs.h

3331

TP_ARGS(fs_info, logical, length, num_stripes),

include/trace/events/btrfs.h

3339

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

3352

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 end,

include/trace/events/btrfs.h

3355

TP_ARGS(fs_info, start, end, found_start, found_end),

include/trace/events/btrfs.h

3364

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

3378

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 logical, u64 length,

include/trace/events/btrfs.h

3381

TP_ARGS(fs_info, logical, length, physical, devid),

include/trace/events/btrfs.h

3390

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

3404

TP_PROTO(const struct btrfs_fs_info *fs_info, long nr),

include/trace/events/btrfs.h

3406

TP_ARGS(fs_info, nr),

include/trace/events/btrfs.h

3412

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

3421

TP_PROTO(const struct btrfs_fs_info *fs_info, long nr),

include/trace/events/btrfs.h

3423

TP_ARGS(fs_info, nr),

include/trace/events/btrfs.h

3432

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

3434

atomic64_read(&fs_info->em_shrinker_nr_to_scan);

include/trace/events/btrfs.h

3436

__entry->last_root_id = fs_info->em_shrinker_last_root;

include/trace/events/btrfs.h

3437

__entry->last_ino = fs_info->em_shrinker_last_ino;

include/trace/events/btrfs.h

3447

TP_PROTO(const struct btrfs_fs_info *fs_info, long nr_dropped, long nr),

include/trace/events/btrfs.h

3449

TP_ARGS(fs_info, nr_dropped, nr),

include/trace/events/btrfs.h

3458

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

3461

__entry->last_root_id = fs_info->em_shrinker_last_root;

include/trace/events/btrfs.h

3462

__entry->last_ino = fs_info->em_shrinker_last_ino;

include/trace/events/btrfs.h

3484

TP_fast_assign_btrfs(inode->root->fs_info,

include/trace/events/btrfs.h

368

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

388

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

392

TP_ARGS(fs_info, existing, map, start, len),

include/trace/events/btrfs.h

403

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

447

TP_fast_assign_btrfs(bi->root->fs_info,

include/trace/events/btrfs.h

498

bi->root->fs_info,

include/trace/events/btrfs.h

589

TP_fast_assign_btrfs(inode->root->fs_info,

include/trace/events/btrfs.h

731

TP_fast_assign_btrfs(inode->root->fs_info,

include/trace/events/btrfs.h

813

TP_fast_assign_btrfs(inode->root->fs_info,

include/trace/events/btrfs.h

875

TP_fast_assign_fsid(inode->root->fs_info);

include/trace/events/btrfs.h

908

TP_fast_assign_fsid(root->fs_info);

include/trace/events/btrfs.h

949

TP_fast_assign_fsid(inode->root->fs_info);

include/trace/events/btrfs.h

989

TP_fast_assign_fsid(inode->root->fs_info);

kernel/bpf/inode.c

50

const struct xattr *xattr_array, void *fs_info);

kernel/bpf/inode.c

935

const struct xattr *xattr_array, void *fs_info)

mm/shmem.c

4175

const struct xattr *xattr_array, void *fs_info)