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

2255

struct ras_fs_if fs_info;

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

2269

sprintf(fs_info.debugfs_name, "%s_err_inject",

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

2271

fs_info.head = obj->head;

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

2272

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

1071

ret = add_direct_ref(ctx->fs_info, preftrees,

fs/btrfs/backref.c

1082

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

fs/btrfs/backref.c

1087

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

fs/btrfs/backref.c

1114

ret = add_indirect_ref(ctx->fs_info, preftrees,

fs/btrfs/backref.c

1120

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

fs/btrfs/backref.c

1144

struct btrfs_fs_info *fs_info = extent_root->fs_info;

fs/btrfs/backref.c

1173

ret = add_direct_ref(fs_info, preftrees,

fs/btrfs/backref.c

1185

ret = add_direct_ref(fs_info, preftrees, 0,

fs/btrfs/backref.c

1192

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

fs/btrfs/backref.c

1221

ret = add_indirect_ref(fs_info, preftrees, root,

fs/btrfs/backref.c

1246

const struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/backref.c

1250

lockdep_assert_held(&fs_info->commit_root_sem);

fs/btrfs/backref.c

1286

entry->gen != btrfs_get_last_root_drop_gen(fs_info))

fs/btrfs/backref.c

1316

const struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/backref.c

1321

lockdep_assert_held(&fs_info->commit_root_sem);

fs/btrfs/backref.c

1338

gen = btrfs_get_last_root_drop_gen(fs_info);

fs/btrfs/backref.c

1380

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

fs/btrfs/backref.c

1397

btrfs_err(ctx->fs_info,

fs/btrfs/backref.c

1408

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

fs/btrfs/backref.c

1450

head = btrfs_find_delayed_ref_head(ctx->fs_info, delayed_refs,

fs/btrfs/backref.c

1469

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

fs/btrfs/backref.c

1570

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

fs/btrfs/backref.c

1617

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

fs/btrfs/backref.c

1804

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

fs/btrfs/backref.c

1807

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

fs/btrfs/backref.c

1859

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/backref.c

1893

down_read(&fs_info->commit_root_sem);

fs/btrfs/backref.c

1895

btrfs_get_tree_mod_seq(fs_info, &elem);

fs/btrfs/backref.c

1918

walk_ctx.fs_info = fs_info;

fs/btrfs/backref.c

2037

btrfs_put_tree_mod_seq(fs_info, &elem);

fs/btrfs/backref.c

2040

up_read(&fs_info->commit_root_sem);

fs/btrfs/backref.c

2202

int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,

fs/btrfs/backref.c

2206

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

fs/btrfs/backref.c

2215

btrfs_err(fs_info,

fs/btrfs/backref.c

2222

if (btrfs_fs_incompat(fs_info, SKINNY_METADATA))

fs/btrfs/backref.c

2247

size = fs_info->nodesize;

fs/btrfs/backref.c

2253

btrfs_debug(fs_info,

fs/btrfs/backref.c

2263

btrfs_debug(fs_info,

fs/btrfs/backref.c

2390

static int iterate_leaf_refs(struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

2399

btrfs_debug(fs_info,

fs/btrfs/backref.c

2405

btrfs_debug(fs_info,

fs/btrfs/backref.c

2430

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

fs/btrfs/backref.c

2439

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

fs/btrfs/backref.c

2450

btrfs_get_tree_mod_seq(ctx->fs_info, &seq_elem);

fs/btrfs/backref.c

2453

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

fs/btrfs/backref.c

2480

ret = iterate_leaf_refs(ctx->fs_info,

fs/btrfs/backref.c

2511

btrfs_debug(ctx->fs_info,

fs/btrfs/backref.c

2515

ret = iterate_leaf_refs(ctx->fs_info, inode_list,

fs/btrfs/backref.c

2525

btrfs_put_tree_mod_seq(ctx->fs_info, &seq_elem);

fs/btrfs/backref.c

2529

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

fs/btrfs/backref.c

2561

int iterate_inodes_from_logical(u64 logical, struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

2574

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

fs/btrfs/backref.c

2586

walk_ctx.fs_info = fs_info;

fs/btrfs/backref.c

2636

btrfs_debug(fs_root->fs_info,

fs/btrfs/backref.c

2827

struct btrfs_backref_iter *btrfs_backref_iter_alloc(struct btrfs_fs_info *fs_info)

fs/btrfs/backref.c

2844

ret->fs_info = fs_info;

fs/btrfs/backref.c

2861

struct btrfs_fs_info *fs_info = iter->fs_info;

fs/btrfs/backref.c

2862

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

fs/btrfs/backref.c

2869

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

3010

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

fs/btrfs/backref.c

3012

btrfs_err(iter->fs_info,

fs/btrfs/backref.c

3035

void btrfs_backref_init_cache(struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

3045

cache->fs_info = fs_info;

fs/btrfs/backref.c

312

trace_btrfs_prelim_ref_merge(fs_info, ref, newref,

fs/btrfs/backref.c

3221

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

fs/btrfs/backref.c

328

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

fs/btrfs/backref.c

3284

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/backref.c

3295

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

fs/btrfs/backref.c

3344

btrfs_err(fs_info,

fs/btrfs/backref.c

3590

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

fs/btrfs/backref.c

3641

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

876

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

fs/btrfs/backref.c

886

static int add_delayed_refs(const struct btrfs_fs_info *fs_info,

fs/btrfs/backref.c

929

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

fs/btrfs/backref.c

942

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

fs/btrfs/backref.c

971

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

fs/btrfs/backref.c

978

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

281

struct btrfs_fs_info *fs_info;

fs/btrfs/backref.h

288

struct btrfs_backref_iter *btrfs_backref_iter_alloc(struct btrfs_fs_info *fs_info);

fs/btrfs/backref.h

417

struct btrfs_fs_info *fs_info;

fs/btrfs/backref.h

428

void btrfs_backref_init_cache(struct btrfs_fs_info *fs_info,

fs/btrfs/backref.h

449

static inline void btrfs_backref_panic(struct btrfs_fs_info *fs_info,

fs/btrfs/backref.h

452

btrfs_panic(fs_info, error,

fs/btrfs/backref.h

88

struct btrfs_fs_info *fs_info;

fs/btrfs/bio.c

1007

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

fs/btrfs/bio.c

1018

btrfs_bio_counter_inc_blocked(fs_info);

fs/btrfs/bio.c

1019

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

fs/btrfs/bio.c

1024

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

fs/btrfs/bio.c

1025

smap.dev = fs_info->dev_replace.tgtdev;

fs/btrfs/bio.c

1031

btrfs_bio_counter_dec(fs_info);

fs/btrfs/bio.c

181

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

fs/btrfs/bio.c

187

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

fs/btrfs/bio.c

196

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

fs/btrfs/bio.c

211

btrfs_debug(fs_info, "no mirror left");

fs/btrfs/bio.c

222

btrfs_repair_io_failure(fs_info, btrfs_ino(inode),

fs/btrfs/bio.c

223

repair_bbio->file_offset, fs_info->sectorsize,

fs/btrfs/bio.c

245

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

fs/btrfs/bio.c

246

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/bio.c

247

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

fs/btrfs/bio.c

260

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

fs/btrfs/bio.c

263

num_copies = btrfs_num_copies(fs_info, logical, sectorsize);

fs/btrfs/bio.c

265

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

fs/btrfs/bio.c

297

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

fs/btrfs/bio.c

305

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

fs/btrfs/bio.c

306

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/bio.c

366

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

fs/btrfs/bio.c

370

return fs_info->endio_meta_workers;

fs/btrfs/bio.c

371

return fs_info->endio_workers;

fs/btrfs/bio.c

394

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

fs/btrfs/bio.c

396

btrfs_bio_counter_dec(fs_info);

fs/btrfs/bio.c

402

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

fs/btrfs/bio.c

413

btrfs_bio_counter_dec(bioc->fs_info);

fs/btrfs/bio.c

430

btrfs_bio_counter_dec(bioc->fs_info);

fs/btrfs/bio.c

458

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

fs/btrfs/bio.c

484

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

fs/btrfs/bio.c

506

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

fs/btrfs/bio.c

513

btrfs_debug(dev->fs_info,

fs/btrfs/bio.c

523

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

fs/btrfs/bio.c

524

percpu_counter_add(&dev->fs_info->stats_read_blocks,

fs/btrfs/bio.c

525

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

fs/btrfs/bio.c

670

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

fs/btrfs/bio.c

683

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

fs/btrfs/bio.c

694

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

fs/btrfs/bio.c

709

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

fs/btrfs/bio.c

722

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

fs/btrfs/bio.c

728

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

fs/btrfs/bio.c

732

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

fs/btrfs/bio.c

733

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

fs/btrfs/bio.c

741

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

fs/btrfs/bio.c

749

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

fs/btrfs/bio.c

764

btrfs_bio_counter_inc_blocked(fs_info);

fs/btrfs/bio.c

765

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

fs/btrfs/bio.c

769

btrfs_bio_counter_dec(fs_info);

fs/btrfs/bio.c

79

static struct btrfs_bio *btrfs_split_bio(struct btrfs_fs_info *fs_info,

fs/btrfs/bio.c

790

split = btrfs_split_bio(fs_info, bbio, map_length);

fs/btrfs/bio.c

793

btrfs_bio_counter_dec(fs_info);

fs/btrfs/bio.c

829

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

fs/btrfs/bio.c

840

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

fs/btrfs/bio.c

853

btrfs_bio_counter_dec(fs_info);

fs/btrfs/bio.c

875

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

fs/btrfs/bio.c

878

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/bio.c

928

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

fs/btrfs/bio.c

940

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

fs/btrfs/bio.c

941

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

fs/btrfs/bio.c

942

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

fs/btrfs/bio.c

952

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

fs/btrfs/bio.c

955

if (btrfs_repair_one_zone(fs_info, logical))

fs/btrfs/bio.c

963

btrfs_bio_counter_inc_blocked(fs_info);

fs/btrfs/bio.c

964

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

fs/btrfs/bio.c

989

btrfs_info_rl(fs_info,

fs/btrfs/bio.c

996

btrfs_bio_counter_dec(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

1000

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

fs/btrfs/block-group.c

1005

write_seqlock(&fs_info->profiles_lock);

fs/btrfs/block-group.c

1007

fs_info->avail_data_alloc_bits &= ~extra_flags;

fs/btrfs/block-group.c

1009

fs_info->avail_metadata_alloc_bits &= ~extra_flags;

fs/btrfs/block-group.c

1011

fs_info->avail_system_alloc_bits &= ~extra_flags;

fs/btrfs/block-group.c

1012

write_sequnlock(&fs_info->profiles_lock);

fs/btrfs/block-group.c

102

spin_unlock(&fs_info->balance_lock);

fs/btrfs/block-group.c

1023

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

fs/btrfs/block-group.c

1031

struct list_head *head = &fs_info->space_info;

fs/btrfs/block-group.c

1047

btrfs_clear_fs_incompat(fs_info, RAID56);

fs/btrfs/block-group.c

1049

btrfs_clear_fs_incompat(fs_info, RAID1C34);

fs/btrfs/block-group.c

1053

static struct btrfs_root *btrfs_block_group_root(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

1055

if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE))

fs/btrfs/block-group.c

1056

return fs_info->block_group_root;

fs/btrfs/block-group.c

1057

return btrfs_extent_root(fs_info, 0);

fs/btrfs/block-group.c

1064

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

1069

root = btrfs_block_group_root(fs_info);

fs/btrfs/block-group.c

1071

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

fs/btrfs/block-group.c

1093

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

fs/btrfs/block-group.c

1109

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

1121

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

fs/btrfs/block-group.c

1140

btrfs_free_ref_tree_range(fs_info, block_group->start,

fs/btrfs/block-group.c

1146

cluster = &fs_info->data_alloc_cluster;

fs/btrfs/block-group.c

1155

cluster = &fs_info->meta_alloc_cluster;

fs/btrfs/block-group.c

1207

write_lock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

1209

&fs_info->block_group_cache_tree);

fs/btrfs/block-group.c

1215

write_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

1226

clear_avail_alloc_bits(fs_info, block_group->flags);

fs/btrfs/block-group.c

1229

clear_incompat_bg_bits(fs_info, block_group->flags);

fs/btrfs/block-group.c

1238

write_lock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

1243

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

fs/btrfs/block-group.c

1253

write_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

1310

btrfs_warn(fs_info,

fs/btrfs/block-group.c

134

u64 btrfs_get_alloc_profile(struct btrfs_fs_info *fs_info, u64 orig_flags)

fs/btrfs/block-group.c

1346

btrfs_remove_chunk_map(fs_info, map);

fs/btrfs/block-group.c

1352

btrfs_dec_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/block-group.c

1357

struct btrfs_fs_info *fs_info, const u64 chunk_offset)

fs/btrfs/block-group.c

1359

struct btrfs_root *root = btrfs_block_group_root(fs_info);

fs/btrfs/block-group.c

1364

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

fs/btrfs/block-group.c

1368

map = btrfs_find_chunk_map(fs_info, chunk_offset, 1);

fs/btrfs/block-group.c

141

seq = read_seqbegin(&fs_info->profiles_lock);

fs/btrfs/block-group.c

144

flags |= fs_info->avail_data_alloc_bits;

fs/btrfs/block-group.c

146

flags |= fs_info->avail_system_alloc_bits;

fs/btrfs/block-group.c

1460

if (btrfs_is_zoned(cache->fs_info)) {

fs/btrfs/block-group.c

1472

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

fs/btrfs/block-group.c

1473

btrfs_info(cache->fs_info,

fs/btrfs/block-group.c

148

flags |= fs_info->avail_metadata_alloc_bits;

fs/btrfs/block-group.c

1483

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

1489

spin_lock(&fs_info->trans_lock);

fs/btrfs/block-group.c

149

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

fs/btrfs/block-group.c

1490

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

fs/btrfs/block-group.c

1494

spin_unlock(&fs_info->trans_lock);

fs/btrfs/block-group.c

1506

mutex_lock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/block-group.c

151

return btrfs_reduce_alloc_profile(fs_info, flags);

fs/btrfs/block-group.c

1517

mutex_unlock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/block-group.c

1537

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/block-group.c

1540

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1546

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1554

void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

1560

const bool async_trim_enabled = btrfs_test_opt(fs_info, DISCARD_ASYNC);

fs/btrfs/block-group.c

1563

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

fs/btrfs/block-group.c

1566

if (btrfs_fs_closing(fs_info))

fs/btrfs/block-group.c

1573

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

fs/btrfs/block-group.c

1576

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1577

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

fs/btrfs/block-group.c

1581

block_group = list_first_entry(&fs_info->unused_bgs,

fs/btrfs/block-group.c

1592

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1594

btrfs_discard_cancel_work(&fs_info->discard_ctl, block_group);

fs/btrfs/block-group.c

1604

if (btrfs_test_opt(fs_info, DISCARD_ASYNC) &&

fs/btrfs/block-group.c

1609

btrfs_discard_queue_work(&fs_info->discard_ctl,

fs/btrfs/block-group.c

1703

trans = btrfs_start_trans_remove_block_group(fs_info,

fs/btrfs/block-group.c

171

!BTRFS_FS_LOG_CLEANUP_ERROR(cache->fs_info))

fs/btrfs/block-group.c

1727

spin_lock(&fs_info->discard_ctl.lock);

fs/btrfs/block-group.c

1729

spin_unlock(&fs_info->discard_ctl.lock);

fs/btrfs/block-group.c

1731

btrfs_discard_queue_work(&fs_info->discard_ctl,

fs/btrfs/block-group.c

1735

spin_unlock(&fs_info->discard_ctl.lock);

fs/btrfs/block-group.c

1755

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

fs/btrfs/block-group.c

1762

trimming = btrfs_test_opt(fs_info, DISCARD_SYNC) ||

fs/btrfs/block-group.c

1763

btrfs_is_zoned(fs_info);

fs/btrfs/block-group.c

1787

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1795

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

180

btrfs_discard_cancel_work(&cache->fs_info->discard_ctl,

fs/btrfs/block-group.c

1802

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1804

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

fs/btrfs/block-group.c

1805

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1806

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/block-group.c

1811

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1812

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

fs/btrfs/block-group.c

1813

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1814

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/block-group.c

1816

btrfs_discard_punt_unused_bgs_list(fs_info);

fs/btrfs/block-group.c

1821

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/block-group.c

1823

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1827

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

fs/btrfs/block-group.c

1834

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

fs/btrfs/block-group.c

1836

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1861

static inline bool btrfs_should_reclaim(const struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

1863

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

fs/btrfs/block-group.c

1866

if (btrfs_fs_closing(fs_info))

fs/btrfs/block-group.c

1869

if (btrfs_is_zoned(fs_info))

fs/btrfs/block-group.c

1870

return btrfs_zoned_should_reclaim(fs_info);

fs/btrfs/block-group.c

1897

struct btrfs_fs_info *fs_info =

fs/btrfs/block-group.c

1903

if (!btrfs_should_reclaim(fs_info))

fs/btrfs/block-group.c

1906

guard(super_write)(fs_info->sb);

fs/btrfs/block-group.c

1908

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE))

fs/btrfs/block-group.c

1915

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

fs/btrfs/block-group.c

1916

btrfs_exclop_finish(fs_info);

fs/btrfs/block-group.c

1920

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1926

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

fs/btrfs/block-group.c

1927

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

fs/btrfs/block-group.c

1933

bg = list_first_entry(&fs_info->reclaim_bgs,

fs/btrfs/block-group.c

1939

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

1970

if (!btrfs_test_opt(fs_info, DISCARD_ASYNC))

fs/btrfs/block-group.c

2007

if (btrfs_need_cleaner_sleep(fs_info)) {

fs/btrfs/block-group.c

2040

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

fs/btrfs/block-group.c

2043

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

fs/btrfs/block-group.c

2064

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/block-group.c

2069

btrfs_delete_unused_bgs(fs_info);

fs/btrfs/block-group.c

2074

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

fs/btrfs/block-group.c

2076

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2078

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2079

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/block-group.c

2081

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2082

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

fs/btrfs/block-group.c

2083

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2084

btrfs_exclop_finish(fs_info);

fs/btrfs/block-group.c

2087

void btrfs_reclaim_bgs(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

2089

btrfs_reclaim_sweep(fs_info);

fs/btrfs/block-group.c

209

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

2090

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2091

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

fs/btrfs/block-group.c

2092

queue_work(system_dfl_wq, &fs_info->reclaim_bgs_work);

fs/btrfs/block-group.c

2093

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2098

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/block-group.c

2100

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

fs/btrfs/block-group.c

2104

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

fs/btrfs/block-group.c

2117

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

fs/btrfs/block-group.c

2119

btrfs_err(fs_info,

fs/btrfs/block-group.c

2126

btrfs_err(fs_info,

fs/btrfs/block-group.c

2139

btrfs_err(fs_info,

fs/btrfs/block-group.c

215

write_lock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

2151

static int find_first_block_group(struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.c

2155

struct btrfs_root *root = btrfs_block_group_root(fs_info);

fs/btrfs/block-group.c

2160

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

fs/btrfs/block-group.c

2167

return read_bg_from_eb(fs_info, &found_key, path);

fs/btrfs/block-group.c

2173

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

fs/btrfs/block-group.c

2178

write_seqlock(&fs_info->profiles_lock);

fs/btrfs/block-group.c

218

&fs_info->block_group_cache_tree, btrfs_bg_start_cmp);

fs/btrfs/block-group.c

2180

fs_info->avail_data_alloc_bits |= extra_flags;

fs/btrfs/block-group.c

2182

fs_info->avail_metadata_alloc_bits |= extra_flags;

fs/btrfs/block-group.c

2184

fs_info->avail_system_alloc_bits |= extra_flags;

fs/btrfs/block-group.c

2185

write_sequnlock(&fs_info->profiles_lock);

fs/btrfs/block-group.c

2202

int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,

fs/btrfs/block-group.c

221

write_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

2213

map = btrfs_get_chunk_map(fs_info, chunk_start, 1);

fs/btrfs/block-group.c

2279

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/block-group.c

2280

const bool zoned = btrfs_is_zoned(fs_info);

fs/btrfs/block-group.c

2289

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

fs/btrfs/block-group.c

2298

ret = btrfs_rmap_block(fs_info, cache->start,

fs/btrfs/block-group.c

2306

btrfs_err(fs_info,

fs/btrfs/block-group.c

2317

ret = btrfs_set_extent_bit(&fs_info->excluded_extents,

fs/btrfs/block-group.c

2332

struct btrfs_fs_info *fs_info, u64 start)

fs/btrfs/block-group.c

2348

cache->fs_info = fs_info;

fs/btrfs/block-group.c

2349

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

fs/btrfs/block-group.c

2375

static int check_chunk_block_group_mappings(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

2389

map = btrfs_find_chunk_map(fs_info, start, 1);

fs/btrfs/block-group.c

2393

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

fs/btrfs/block-group.c

2395

btrfs_err(fs_info,

fs/btrfs/block-group.c

2405

btrfs_err(fs_info,

fs/btrfs/block-group.c

2550

static int fill_dummy_bgs(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

2555

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

fs/btrfs/block-group.c

2560

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

fs/btrfs/block-group.c

2572

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

fs/btrfs/block-group.c

2590

btrfs_add_bg_to_space_info(fs_info, bg);

fs/btrfs/block-group.c

2592

set_avail_alloc_bits(fs_info, bg->flags);

fs/btrfs/block-group.c

2595

btrfs_init_global_block_rsv(fs_info);

fs/btrfs/block-group.c

2729

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

2731

struct btrfs_root *root = btrfs_block_group_root(fs_info);

fs/btrfs/block-group.c

2738

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

fs/btrfs/block-group.c

2758

if (btrfs_fs_incompat(fs_info, REMAP_TREE))

fs/btrfs/block-group.c

2777

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/block-group.c

2778

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/block-group.c

28

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

2818

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

2825

map = btrfs_get_chunk_map(fs_info, chunk_offset, chunk_size);

fs/btrfs/block-group.c

2838

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

fs/btrfs/block-group.c

2848

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

fs/btrfs/block-group.c

2863

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

288

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/block-group.c

2883

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

2885

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

2906

btrfs_dec_delayed_refs_rsv_bg_inserts(fs_info);

fs/btrfs/block-group.c

2908

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

291

read_lock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

2912

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

2952

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

fs/btrfs/block-group.c

2957

if (!btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))

fs/btrfs/block-group.c

2961

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

fs/btrfs/block-group.c

2965

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

fs/btrfs/block-group.c

297

read_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

2973

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

2979

cache = btrfs_create_block_group(fs_info, chunk_offset);

fs/btrfs/block-group.c

299

return btrfs_lookup_first_block_group(fs_info, next_bytenr);

fs/btrfs/block-group.c

2994

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

fs/btrfs/block-group.c

2996

if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE))

fs/btrfs/block-group.c

30

return (btrfs_test_opt(fs_info, FRAGMENT_METADATA) &&

fs/btrfs/block-group.c

3039

trace_btrfs_add_block_group(fs_info, cache, 1);

fs/btrfs/block-group.c

3040

btrfs_add_bg_to_space_info(fs_info, cache);

fs/btrfs/block-group.c

3041

btrfs_update_global_block_rsv(fs_info);

fs/btrfs/block-group.c

3051

btrfs_inc_delayed_refs_rsv_bg_inserts(fs_info);

fs/btrfs/block-group.c

3053

set_avail_alloc_bits(fs_info, type);

fs/btrfs/block-group.c

3069

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/block-group.c

3072

struct btrfs_root *root = btrfs_block_group_root(fs_info);

fs/btrfs/block-group.c

3078

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

fs/btrfs/block-group.c

308

read_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

3088

if (sb_rdonly(fs_info->sb)) {

fs/btrfs/block-group.c

3089

mutex_lock(&fs_info->ro_block_group_mutex);

fs/btrfs/block-group.c

3091

mutex_unlock(&fs_info->ro_block_group_mutex);

fs/btrfs/block-group.c

3107

mutex_lock(&fs_info->ro_block_group_mutex);

fs/btrfs/block-group.c

3111

mutex_unlock(&fs_info->ro_block_group_mutex);

fs/btrfs/block-group.c

3114

ret = btrfs_wait_for_commit(fs_info, transid);

fs/btrfs/block-group.c

3126

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

fs/btrfs/block-group.c

3156

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

fs/btrfs/block-group.c

3173

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

fs/btrfs/block-group.c

3174

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

3176

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

3179

mutex_unlock(&fs_info->ro_block_group_mutex);

fs/btrfs/block-group.c

3194

if (btrfs_is_zoned(cache->fs_info)) {

fs/btrfs/block-group.c

32

(btrfs_test_opt(fs_info, FRAGMENT_DATA) &&

fs/btrfs/block-group.c

3214

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

3216

struct btrfs_root *root = btrfs_block_group_root(fs_info);

fs/btrfs/block-group.c

3227

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

fs/btrfs/block-group.c

327

struct btrfs_block_group *btrfs_inc_nocow_writers(struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.c

3275

if (btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/block-group.c

3312

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

3321

if (!btrfs_test_opt(fs_info, SPACE_CACHE))

fs/btrfs/block-group.c

333

bg = btrfs_lookup_block_group(fs_info, bytenr);

fs/btrfs/block-group.c

3388

ret = btrfs_check_trunc_cache_free_space(fs_info,

fs/btrfs/block-group.c

3389

&fs_info->global_block_rsv);

fs/btrfs/block-group.c

3400

!btrfs_test_opt(fs_info, SPACE_CACHE)) {

fs/btrfs/block-group.c

3433

cache_size *= fs_info->sectorsize;

fs/btrfs/block-group.c

3473

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

3479

!btrfs_test_opt(fs_info, SPACE_CACHE))

fs/btrfs/block-group.c

3510

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

3629

btrfs_dec_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/block-group.c

3667

btrfs_cleanup_dirty_bgs(cur_trans, fs_info);

fs/btrfs/block-group.c

3675

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

3777

btrfs_dec_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/block-group.c

378

void btrfs_dec_block_group_reservations(struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.c

3808

struct btrfs_fs_info *info = trans->fs_info;

fs/btrfs/block-group.c

383

bg = btrfs_lookup_block_group(fs_info, start);

fs/btrfs/block-group.c

3953

trace_btrfs_space_reservation(cache->fs_info, "space_info",

fs/btrfs/block-group.c

40

if (!btrfs_is_zoned(block_group->fs_info))

fs/btrfs/block-group.c

4005

else if (btrfs_is_zoned(cache->fs_info))

fs/btrfs/block-group.c

4026

static bool should_alloc_chunk(const struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.c

4040

thresh = btrfs_super_total_bytes(fs_info->super_copy);

fs/btrfs/block-group.c

4054

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

fs/btrfs/block-group.c

4057

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

fs/btrfs/block-group.c

4127

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

fs/btrfs/block-group.c

4131

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

fs/btrfs/block-group.c

4283

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

4326

should_alloc = should_alloc_chunk(fs_info, space_info, force);

fs/btrfs/block-group.c

4348

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4349

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4360

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4375

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

fs/btrfs/block-group.c

4376

fs_info->data_chunk_allocations++;

fs/btrfs/block-group.c

4377

if (!(fs_info->data_chunk_allocations %

fs/btrfs/block-group.c

4378

fs_info->metadata_ratio))

fs/btrfs/block-group.c

4379

force_metadata_allocation(fs_info);

fs/btrfs/block-group.c

4413

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4418

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

fs/btrfs/block-group.c

4424

num_dev = fs_info->fs_devices->rw_devices;

fs/btrfs/block-group.c

4433

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

4442

lockdep_assert_held(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4444

info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);

fs/btrfs/block-group.c

4449

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

fs/btrfs/block-group.c

4450

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

fs/btrfs/block-group.c

4456

u64 flags = btrfs_system_alloc_profile(fs_info);

fs/btrfs/block-group.c

4460

space_info = btrfs_find_space_info(fs_info, flags);

fs/btrfs/block-group.c

4496

ret = btrfs_block_rsv_add(fs_info,

fs/btrfs/block-group.c

4497

&fs_info->chunk_block_rsv,

fs/btrfs/block-group.c

4510

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

4511

const u64 num_devs = get_profile_num_devs(fs_info, type);

fs/btrfs/block-group.c

4515

bytes = btrfs_calc_metadata_size(fs_info, num_devs) +

fs/btrfs/block-group.c

4516

btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/block-group.c

4540

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

4544

bytes = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/block-group.c

4546

bytes = btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/block-group.c

4548

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4550

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/block-group.c

4579

struct btrfs_fs_info *info = space_info->fs_info;

fs/btrfs/block-group.c

4735

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

4746

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

fs/btrfs/block-group.c

4750

btrfs_remove_chunk_map(fs_info, map);

fs/btrfs/block-group.c

4851

if (btrfs_is_zoned(bg->fs_info))

fs/btrfs/block-group.c

4861

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/block-group.c

4864

if (btrfs_test_opt(fs_info, DISCARD_ASYNC)) {

fs/btrfs/block-group.c

4869

btrfs_discard_queue_work(&fs_info->discard_ctl, bg);

fs/btrfs/block-group.c

4871

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

4882

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

fs/btrfs/block-group.c

4883

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

4897

int btrfs_populate_fully_remapped_bgs_list(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.c

4901

node_bg = rb_first_cached(&fs_info->block_group_cache_tree);

fs/btrfs/block-group.c

4902

node_chunk = rb_first_cached(&fs_info->mapping_tree);

fs/btrfs/block-group.c

4922

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

4926

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

fs/btrfs/block-group.c

4928

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

fs/btrfs/block-group.c

4931

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/block-group.c

4942

if (btrfs_test_opt(fs_info, DISCARD_ASYNC)) {

fs/btrfs/block-group.c

499

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

503

fs_info->nodesize : fs_info->sectorsize;

fs/btrfs/block-group.c

533

struct btrfs_fs_info *info = block_group->fs_info;

fs/btrfs/block-group.c

56

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

fs/btrfs/block-group.c

58

const struct btrfs_balance_control *bctl = fs_info->balance_ctl;

fs/btrfs/block-group.c

596

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

607

lockdep_assert_held_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

609

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

fs/btrfs/block-group.c

611

btrfs_err(fs_info,

fs/btrfs/block-group.c

637

lockdep_assert_held_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

680

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

701

lockdep_assert_held_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

725

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/block-group.c

741

extent_root = btrfs_extent_root(fs_info, last);

fs/btrfs/block-group.c

743

btrfs_err(fs_info,

fs/btrfs/block-group.c

781

if (btrfs_fs_closing_done(fs_info)) {

fs/btrfs/block-group.c

794

rwsem_is_contended(&fs_info->commit_root_sem)) {

fs/btrfs/block-group.c

796

up_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

800

down_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

841

fs_info->nodesize;

fs/btrfs/block-group.c

85

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

fs/btrfs/block-group.c

861

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

fs/btrfs/block-group.c

868

struct btrfs_fs_info *fs_info;

fs/btrfs/block-group.c

87

u64 num_devices = fs_info->fs_devices->rw_devices;

fs/btrfs/block-group.c

874

fs_info = block_group->fs_info;

fs/btrfs/block-group.c

877

down_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

880

if (btrfs_test_opt(fs_info, SPACE_CACHE)) {

fs/btrfs/block-group.c

904

if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&

fs/btrfs/block-group.c

905

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

fs/btrfs/block-group.c

929

up_read(&fs_info->commit_root_sem);

fs/btrfs/block-group.c

941

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/block-group.c

946

if (btrfs_is_zoned(fs_info))

fs/btrfs/block-group.c

96

spin_lock(&fs_info->balance_lock);

fs/btrfs/block-group.c

97

target = get_restripe_target(fs_info, flags);

fs/btrfs/block-group.c

983

write_lock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

985

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

fs/btrfs/block-group.c

986

write_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/block-group.c

99

spin_unlock(&fs_info->balance_lock);

fs/btrfs/block-group.c

990

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

fs/btrfs/block-group.h

122

struct btrfs_fs_info *fs_info;

fs/btrfs/block-group.h

331

void btrfs_dec_block_group_reservations(struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.h

334

struct btrfs_block_group *btrfs_inc_nocow_writers(struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.h

346

struct btrfs_fs_info *fs_info,

fs/btrfs/block-group.h

351

void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info);

fs/btrfs/block-group.h

354

void btrfs_reclaim_bgs(struct btrfs_fs_info *fs_info);

fs/btrfs/block-group.h

381

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

fs/btrfs/block-group.h

384

int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,

fs/btrfs/block-group.h

387

static inline u64 btrfs_data_alloc_profile(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.h

389

return btrfs_get_alloc_profile(fs_info, BTRFS_BLOCK_GROUP_DATA);

fs/btrfs/block-group.h

392

static inline u64 btrfs_metadata_alloc_profile(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.h

394

return btrfs_get_alloc_profile(fs_info, BTRFS_BLOCK_GROUP_METADATA);

fs/btrfs/block-group.h

397

static inline u64 btrfs_system_alloc_profile(struct btrfs_fs_info *fs_info)

fs/btrfs/block-group.h

399

return btrfs_get_alloc_profile(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);

fs/btrfs/block-group.h

422

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

327

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

fs/btrfs/block-rsv.c

338

read_lock(&fs_info->global_root_lock);

fs/btrfs/block-rsv.c

339

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

fs/btrfs/block-rsv.c

348

read_unlock(&fs_info->global_root_lock);

fs/btrfs/block-rsv.c

350

if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE)) {

fs/btrfs/block-rsv.c

351

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

fs/btrfs/block-rsv.c

355

if (btrfs_fs_incompat(fs_info, RAID_STRIPE_TREE)) {

fs/btrfs/block-rsv.c

356

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

fs/btrfs/block-rsv.c

372

btrfs_calc_insert_metadata_size(fs_info, min_items) +

fs/btrfs/block-rsv.c

373

btrfs_calc_delayed_ref_bytes(fs_info,

fs/btrfs/block-rsv.c

402

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/block-rsv.c

410

root->block_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/block-rsv.c

415

root->block_rsv = &fs_info->global_block_rsv;

fs/btrfs/block-rsv.c

418

root->block_rsv = &fs_info->chunk_block_rsv;

fs/btrfs/block-rsv.c

421

root->block_rsv = &fs_info->treelog_rsv;

fs/btrfs/block-rsv.c

424

root->block_rsv = &fs_info->remap_block_rsv;

fs/btrfs/block-rsv.c

432

void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info)

fs/btrfs/block-rsv.c

436

space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);

fs/btrfs/block-rsv.c

437

fs_info->chunk_block_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

439

space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA_REMAP);

fs/btrfs/block-rsv.c

440

fs_info->remap_block_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

442

space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);

fs/btrfs/block-rsv.c

443

fs_info->global_block_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

444

fs_info->trans_block_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

445

fs_info->empty_block_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

446

fs_info->delayed_block_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

447

fs_info->delayed_refs_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

450

if (!btrfs_is_zoned(fs_info)) {

fs/btrfs/block-rsv.c

451

fs_info->treelog_rsv.space_info = space_info;

fs/btrfs/block-rsv.c

454

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

fs/btrfs/block-rsv.c

457

btrfs_update_global_block_rsv(fs_info);

fs/btrfs/block-rsv.c

460

void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info)

fs/btrfs/block-rsv.c

462

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

fs/btrfs/block-rsv.c

464

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

fs/btrfs/block-rsv.c

465

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

fs/btrfs/block-rsv.c

466

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

fs/btrfs/block-rsv.c

467

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

fs/btrfs/block-rsv.c

468

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

fs/btrfs/block-rsv.c

469

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

fs/btrfs/block-rsv.c

470

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

fs/btrfs/block-rsv.c

471

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

fs/btrfs/block-rsv.c

472

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

fs/btrfs/block-rsv.c

473

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

fs/btrfs/block-rsv.c

480

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/block-rsv.c

484

(root == fs_info->uuid_root) ||

fs/btrfs/block-rsv.c

492

block_rsv = &fs_info->empty_block_rsv;

fs/btrfs/block-rsv.c

501

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/block-rsv.c

503

struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;

fs/btrfs/block-rsv.c

521

btrfs_update_global_block_rsv(fs_info);

fs/btrfs/block-rsv.c

530

btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {

fs/btrfs/block-rsv.c

570

int btrfs_check_trunc_cache_free_space(const struct btrfs_fs_info *fs_info,

fs/btrfs/block-rsv.c

577

needed_bytes = btrfs_calc_insert_metadata_size(fs_info, 1) +

fs/btrfs/block-rsv.c

578

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

537

inode->root->fs_info->block_min_order,

fs/btrfs/btrfs_inode.h

538

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

fs/btrfs/btrfs_inode.h

542

void btrfs_calculate_block_csum_folio(struct btrfs_fs_info *fs_info,

fs/btrfs/btrfs_inode.h

544

void btrfs_calculate_block_csum_pages(struct btrfs_fs_info *fs_info,

fs/btrfs/btrfs_inode.h

546

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

fs/btrfs/btrfs_inode.h

567

int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, long nr,

fs/btrfs/btrfs_inode.h

622

void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info);

fs/btrfs/btrfs_inode.h

623

int btrfs_wait_on_delayed_iputs(struct btrfs_fs_info *fs_info);

fs/btrfs/btrfs_inode.h

634

int btrfs_encoded_io_compression_from_extent(struct btrfs_fs_info *fs_info,

fs/btrfs/compression.c

1012

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

fs/btrfs/compression.c

1025

workspace = get_workspace(fs_info, type, level);

fs/btrfs/compression.c

1050

put_workspace(fs_info, type, workspace);

fs/btrfs/compression.c

1060

struct btrfs_fs_info *fs_info = cb_to_fs_info(cb);

fs/btrfs/compression.c

1065

workspace = get_workspace(fs_info, type, 0);

fs/btrfs/compression.c

1067

put_workspace(fs_info, type, workspace);

fs/btrfs/compression.c

1083

struct btrfs_fs_info *fs_info = folio_to_fs_info(dest_folio);

fs/btrfs/compression.c

1085

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/compression.c

1095

workspace = get_workspace(fs_info, type, 0);

fs/btrfs/compression.c

1098

put_workspace(fs_info, type, workspace);

fs/btrfs/compression.c

1103

int btrfs_alloc_compress_wsm(struct btrfs_fs_info *fs_info)

fs/btrfs/compression.c

1107

ret = alloc_workspace_manager(fs_info, BTRFS_COMPRESS_NONE);

fs/btrfs/compression.c

1110

ret = alloc_workspace_manager(fs_info, BTRFS_COMPRESS_ZLIB);

fs/btrfs/compression.c

1113

ret = alloc_workspace_manager(fs_info, BTRFS_COMPRESS_LZO);

fs/btrfs/compression.c

1116

ret = zstd_alloc_workspace_manager(fs_info);

fs/btrfs/compression.c

1121

btrfs_free_compress_wsm(fs_info);

fs/btrfs/compression.c

1125

void btrfs_free_compress_wsm(struct btrfs_fs_info *fs_info)

fs/btrfs/compression.c

1127

free_workspace_manager(fs_info, BTRFS_COMPRESS_NONE);

fs/btrfs/compression.c

1128

free_workspace_manager(fs_info, BTRFS_COMPRESS_ZLIB);

fs/btrfs/compression.c

1129

free_workspace_manager(fs_info, BTRFS_COMPRESS_LZO);

fs/btrfs/compression.c

1130

zstd_free_workspace_manager(fs_info);

fs/btrfs/compression.c

1572

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

fs/btrfs/compression.c

1573

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

fs/btrfs/compression.c

1642

put_workspace(fs_info, 0, ws_list);

fs/btrfs/compression.c

183

struct folio *btrfs_alloc_compr_folio(struct btrfs_fs_info *fs_info)

fs/btrfs/compression.c

188

if (fs_info->block_min_order)

fs/btrfs/compression.c

203

return folio_alloc(GFP_NOFS, 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

374

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/compression.c

400

if (fs_info->sectorsize < PAGE_SIZE)

fs/btrfs/compression.c

404

if (fs_info->block_min_order)

fs/btrfs/compression.c

424

fs_info->sectorsize_bits;

fs/btrfs/compression.c

474

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

fs/btrfs/compression.c

508

if (fs_info->sectorsize < PAGE_SIZE)

fs/btrfs/compression.c

509

btrfs_folio_set_lock(fs_info, folio, cur, add_size);

fs/btrfs/compression.c

530

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

fs/btrfs/compression.c

534

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/compression.c

545

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

fs/btrfs/compression.c

574

folio = btrfs_alloc_compr_folio(fs_info);

fs/btrfs/compression.c

666

static struct list_head *alloc_heuristic_ws(struct btrfs_fs_info *fs_info)

fs/btrfs/compression.c

703

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

fs/btrfs/compression.c

706

case BTRFS_COMPRESS_NONE: return alloc_heuristic_ws(fs_info);

fs/btrfs/compression.c

707

case BTRFS_COMPRESS_ZLIB: return zlib_alloc_workspace(fs_info, level);

fs/btrfs/compression.c

708

case BTRFS_COMPRESS_LZO: return lzo_alloc_workspace(fs_info);

fs/btrfs/compression.c

709

case BTRFS_COMPRESS_ZSTD: return zstd_alloc_workspace(fs_info, level);

fs/btrfs/compression.c

735

static int alloc_workspace_manager(struct btrfs_fs_info *fs_info,

fs/btrfs/compression.c

741

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

fs/btrfs/compression.c

750

fs_info->compr_wsm[type] = gwsm;

fs/btrfs/compression.c

756

workspace = alloc_workspace(fs_info, type, 0);

fs/btrfs/compression.c

758

btrfs_warn(fs_info,

fs/btrfs/compression.c

769

static void free_workspace_manager(struct btrfs_fs_info *fs_info,

fs/btrfs/compression.c

773

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

fs/btrfs/compression.c

779

fs_info->compr_wsm[type] = NULL;

fs/btrfs/compression.c

795

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

fs/btrfs/compression.c

797

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

fs/btrfs/compression.c

843

workspace = alloc_workspace(fs_info, type, level);

fs/btrfs/compression.c

866

btrfs_warn(fs_info,

fs/btrfs/compression.c

874

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

fs/btrfs/compression.c

877

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

fs/btrfs/compression.c

878

case BTRFS_COMPRESS_ZLIB: return zlib_get_workspace(fs_info, level);

fs/btrfs/compression.c

879

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

fs/btrfs/compression.c

880

case BTRFS_COMPRESS_ZSTD: return zstd_get_workspace(fs_info, level);

fs/btrfs/compression.c

894

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

fs/btrfs/compression.c

896

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

fs/btrfs/compression.c

925

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

fs/btrfs/compression.c

928

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

fs/btrfs/compression.c

929

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

fs/btrfs/compression.c

930

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

fs/btrfs/compression.c

931

case BTRFS_COMPRESS_ZSTD: return zstd_put_workspace(fs_info, ws);

fs/btrfs/compression.c

981

btrfs_crit(inode->root->fs_info,

fs/btrfs/compression.h

101

struct folio *btrfs_alloc_compr_folio(struct btrfs_fs_info *fs_info);

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

1060

btrfs_crit(fs_info,

fs/btrfs/ctree.c

1153

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

1188

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

fs/btrfs/ctree.c

1248

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

fs/btrfs/ctree.c

1300

static void reada_for_search(struct btrfs_fs_info *fs_info,

fs/btrfs/ctree.c

1330

nread_max = node->fs_info->nodesize;

fs/btrfs/ctree.c

1338

blocksize = fs_info->nodesize;

fs/btrfs/ctree.c

1342

eb = find_extent_buffer(fs_info, search);

fs/btrfs/ctree.c

1474

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

1500

tmp = find_extent_buffer(fs_info, blocknr);

fs/btrfs/ctree.c

1503

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

fs/btrfs/ctree.c

1561

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

fs/btrfs/ctree.c

1563

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

fs/btrfs/ctree.c

1633

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

1637

BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 3) {

fs/btrfs/ctree.c

1650

BTRFS_NODEPTRS_PER_BLOCK(fs_info) / 2) {

fs/btrfs/ctree.c

1814

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

fs/btrfs/ctree.c

2010

struct btrfs_fs_info *fs_info;

fs/btrfs/ctree.c

2025

fs_info = root->fs_info;

fs/btrfs/ctree.c

2067

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

fs/btrfs/ctree.c

2070

down_read(&fs_info->commit_root_sem);

fs/btrfs/ctree.c

218

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

224

spin_lock(&fs_info->trans_lock);

fs/btrfs/ctree.c

2240

up_read(&fs_info->commit_root_sem);

fs/btrfs/ctree.c

2263

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

229

&fs_info->dirty_cowonly_roots);

fs/btrfs/ctree.c

232

&fs_info->dirty_cowonly_roots);

fs/btrfs/ctree.c

2337

b = btrfs_tree_mod_log_rewind(fs_info, b, time_seq);

fs/btrfs/ctree.c

234

spin_unlock(&fs_info->trans_lock);

fs/btrfs/ctree.c

247

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

256

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

fs/btrfs/ctree.c

2600

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/ctree.c

2611

btrfs_crit(fs_info,

fs/btrfs/ctree.c

2624

btrfs_crit(fs_info,

fs/btrfs/ctree.c

2683

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

fs/btrfs/ctree.c

2685

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

fs/btrfs/ctree.c

2687

btrfs_crit(left->fs_info,

fs/btrfs/ctree.c

2707

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/ctree.c

2715

push_items = BTRFS_NODEPTRS_PER_BLOCK(fs_info) - dst_nritems;

fs/btrfs/ctree.c

2787

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/ctree.c

2799

push_items = BTRFS_NODEPTRS_PER_BLOCK(fs_info) - dst_nritems;

fs/btrfs/ctree.c

285

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

fs/btrfs/ctree.c

2942

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

fs/btrfs/ctree.c

2988

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

3016

BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 3)

fs/btrfs/ctree.c

3100

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/ctree.c

3104

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

fs/btrfs/ctree.c

3106

btrfs_crit(fs_info,

fs/btrfs/ctree.c

3109

(unsigned long) BTRFS_LEAF_DATA_SIZE(fs_info),

fs/btrfs/ctree.c

3126

struct btrfs_fs_info *fs_info = right->fs_info;

fs/btrfs/ctree.c

3190

BTRFS_LEAF_DATA_SIZE(fs_info) - data_end);

fs/btrfs/ctree.c

3193

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

fs/btrfs/ctree.c

3204

push_space = BTRFS_LEAF_DATA_SIZE(fs_info);

fs/btrfs/ctree.c

3337

struct btrfs_fs_info *fs_info = left->fs_info;

fs/btrfs/ctree.c

3387

push_space = BTRFS_LEAF_DATA_SIZE(fs_info) -

fs/btrfs/ctree.c

3401

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

fs/btrfs/ctree.c

3409

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

fs/btrfs/ctree.c

3418

BTRFS_LEAF_DATA_SIZE(fs_info) - push_space,

fs/btrfs/ctree.c

3427

push_space = BTRFS_LEAF_DATA_SIZE(fs_info);

fs/btrfs/ctree.c

3538

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/ctree.c

354

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

3551

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

fs/btrfs/ctree.c

3554

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

fs/btrfs/ctree.c

3671

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

3681

sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(fs_info))

fs/btrfs/ctree.c

3726

BTRFS_LEAF_DATA_SIZE(fs_info)) {

fs/btrfs/ctree.c

3733

data_size > BTRFS_LEAF_DATA_SIZE(fs_info)) {

fs/btrfs/ctree.c

3742

BTRFS_LEAF_DATA_SIZE(fs_info)) {

fs/btrfs/ctree.c

3751

data_size > BTRFS_LEAF_DATA_SIZE(fs_info)) {

fs/btrfs/ctree.c

379

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

fs/btrfs/ctree.c

385

btrfs_crit(fs_info,

fs/btrfs/ctree.c

404

btrfs_crit(fs_info,

fs/btrfs/ctree.c

4130

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

fs/btrfs/ctree.c

4175

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

4204

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

fs/btrfs/ctree.c

4214

btrfs_crit(fs_info,

fs/btrfs/ctree.c

4473

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

4531

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

fs/btrfs/ctree.c

472

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

4789

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

4822

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

fs/btrfs/ctree.c

4827

down_read(&fs_info->commit_root_sem);

fs/btrfs/ctree.c

487

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

fs/btrfs/ctree.c

49

return BTRFS_LEAF_DATA_SIZE(leaf->fs_info);

fs/btrfs/ctree.c

4962

up_read(&fs_info->commit_root_sem);

fs/btrfs/ctree.c

522

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

fs/btrfs/ctree.c

606

if (btrfs_is_testing(root->fs_info))

fs/btrfs/ctree.c

652

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

657

btrfs_crit(fs_info,

fs/btrfs/ctree.c

669

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

fs/btrfs/ctree.c

670

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

fs/btrfs/ctree.c

672

btrfs_crit(fs_info,

fs/btrfs/ctree.c

675

fs_info->running_transaction->transid,

fs/btrfs/ctree.c

676

fs_info->generation);

fs/btrfs/ctree.c

748

btrfs_err(eb->fs_info,

fs/btrfs/ctree.c

805

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

fs/btrfs/ctree.c

813

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

fs/btrfs/ctree.c

838

eb = read_tree_block(parent->fs_info, btrfs_node_blockptr(parent, slot),

fs/btrfs/ctree.c

928

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ctree.c

964

BTRFS_NODEPTRS_PER_BLOCK(fs_info) / 4)

fs/btrfs/ctree.h

185

struct btrfs_fs_info *fs_info;

fs/btrfs/defrag.c

103

static inline bool need_auto_defrag(struct btrfs_fs_info *fs_info)

fs/btrfs/defrag.c

1043

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

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

1155

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

fs/btrfs/defrag.c

1182

btrfs_folio_clamp_clear_checked(fs_info, folio, start, len);

fs/btrfs/defrag.c

1183

btrfs_folio_clamp_set_dirty(fs_info, folio, start, len);

fs/btrfs/defrag.c

1200

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

1278

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

fs/btrfs/defrag.c

1328

inode->root->fs_info->sectorsize_bits;

fs/btrfs/defrag.c

1360

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

fs/btrfs/defrag.c

140

spin_lock(&fs_info->defrag_inodes_lock);

fs/btrfs/defrag.c

1414

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

fs/btrfs/defrag.c

1415

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

fs/btrfs/defrag.c

1430

if (btrfs_defrag_cancelled(fs_info)) {

fs/btrfs/defrag.c

1491

btrfs_set_fs_incompat(fs_info, COMPRESS_LZO);

fs/btrfs/defrag.c

1493

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

960

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

fs/btrfs/defrag.c

983

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

145

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

fs/btrfs/delalloc-space.c

150

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

fs/btrfs/delalloc-space.c

151

round_down(start, fs_info->sectorsize);

fs/btrfs/delalloc-space.c

152

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

fs/btrfs/delalloc-space.c

185

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

fs/btrfs/delalloc-space.c

187

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

fs/btrfs/delalloc-space.c

202

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

fs/btrfs/delalloc-space.c

205

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

fs/btrfs/delalloc-space.c

206

round_down(start, fs_info->sectorsize);

fs/btrfs/delalloc-space.c

207

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

fs/btrfs/delalloc-space.c

228

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

fs/btrfs/delalloc-space.c

238

released = btrfs_block_rsv_release(fs_info, block_rsv, 0,

fs/btrfs/delalloc-space.c

241

trace_btrfs_space_reservation(fs_info, "delalloc",

fs/btrfs/delalloc-space.c

250

static void btrfs_calculate_inode_block_rsv_size(struct btrfs_fs_info *fs_info,

fs/btrfs/delalloc-space.c

266

reserve_size = btrfs_calc_insert_metadata_size(fs_info,

fs/btrfs/delalloc-space.c

268

reserve_size += btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/delalloc-space.c

273

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

fs/btrfs/delalloc-space.c

274

reserve_size += btrfs_calc_insert_metadata_size(fs_info, csum_leaves);

fs/btrfs/delalloc-space.c

282

qgroup_rsv_size = (u64)outstanding_extents * fs_info->nodesize;

fs/btrfs/delalloc-space.c

294

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

fs/btrfs/delalloc-space.c

295

u64 nr_extents = count_max_extents(fs_info, num_bytes);

fs/btrfs/delalloc-space.c

297

u64 inode_update = btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/delalloc-space.c

302

csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, disk_num_bytes);

fs/btrfs/delalloc-space.c

304

*meta_reserve = btrfs_calc_insert_metadata_size(fs_info,

fs/btrfs/delalloc-space.c

312

*qgroup_reserve = nr_extents * fs_info->nodesize;

fs/btrfs/delalloc-space.c

319

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delalloc-space.c

342

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

fs/btrfs/delalloc-space.c

343

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

fs/btrfs/delalloc-space.c

374

nr_extents = count_max_extents(fs_info, num_bytes);

fs/btrfs/delalloc-space.c

379

btrfs_calculate_inode_block_rsv_size(fs_info, inode);

fs/btrfs/delalloc-space.c

384

trace_btrfs_space_reservation(root->fs_info, "delalloc",

fs/btrfs/delalloc-space.c

408

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

fs/btrfs/delalloc-space.c

410

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

fs/btrfs/delalloc-space.c

414

btrfs_calculate_inode_block_rsv_size(fs_info, inode);

fs/btrfs/delalloc-space.c

417

if (btrfs_is_testing(fs_info))

fs/btrfs/delalloc-space.c

437

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

fs/btrfs/delalloc-space.c

441

num_extents = count_max_extents(fs_info, num_bytes);

fs/btrfs/delalloc-space.c

443

btrfs_calculate_inode_block_rsv_size(fs_info, inode);

fs/btrfs/delalloc-space.c

446

if (btrfs_is_testing(fs_info))

fs/btrfs/delalloc-space.c

455

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

fs/btrfs/delalloc-space.c

456

const u32 reserved_num_extents = count_max_extents(fs_info, reserved_len);

fs/btrfs/delalloc-space.c

457

const u32 new_num_extents = count_max_extents(fs_info, new_len);

fs/btrfs/delalloc-space.c

466

btrfs_calculate_inode_block_rsv_size(fs_info, inode);

fs/btrfs/delalloc-space.c

469

if (btrfs_is_testing(fs_info))

fs/btrfs/delayed-inode.c

1002

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delayed-inode.c

1086

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

fs/btrfs/delayed-inode.c

1139

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-inode.c

1155

trans->block_rsv = &fs_info->delayed_block_rsv;

fs/btrfs/delayed-inode.c

1157

curr_node = btrfs_first_delayed_node(fs_info, &curr_delayed_node_tracker);

fs/btrfs/delayed-inode.c

1233

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

fs/btrfs/delayed-inode.c

1245

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

fs/btrfs/delayed-inode.c

1278

trans->block_rsv = &fs_info->delayed_block_rsv;

fs/btrfs/delayed-inode.c

1292

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/delayed-inode.c

1359

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

fs/btrfs/delayed-inode.c

1365

btrfs_btree_balance_dirty_nodelay(root->fs_info);

fs/btrfs/delayed-inode.c

1383

struct btrfs_fs_info *fs_info, int nr)

fs/btrfs/delayed-inode.c

1395

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

fs/btrfs/delayed-inode.c

1399

void btrfs_assert_delayed_root_empty(struct btrfs_fs_info *fs_info)

fs/btrfs/delayed-inode.c

1404

node = btrfs_first_delayed_node(fs_info, &delayed_node_tracker);

fs/btrfs/delayed-inode.c

1425

void btrfs_balance_delayed_items(struct btrfs_fs_info *fs_info)

fs/btrfs/delayed-inode.c

1427

struct btrfs_delayed_root *delayed_root = &fs_info->delayed_root;

fs/btrfs/delayed-inode.c

1430

btrfs_workqueue_normal_congested(fs_info->delayed_workers))

fs/btrfs/delayed-inode.c

1439

ret = btrfs_wq_run_delayed_node(delayed_root, fs_info, 0);

fs/btrfs/delayed-inode.c

1448

btrfs_wq_run_delayed_node(delayed_root, fs_info, BTRFS_DELAYED_BATCH);

fs/btrfs/delayed-inode.c

1453

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-inode.c

1454

const u64 bytes = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/delayed-inode.c

1456

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

fs/btrfs/delayed-inode.c

1466

trace_btrfs_space_reservation(fs_info, "transaction",

fs/btrfs/delayed-inode.c

1468

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

fs/btrfs/delayed-inode.c

1480

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-inode.c

1481

const unsigned int leaf_data_size = BTRFS_LEAF_DATA_SIZE(fs_info);

fs/btrfs/delayed-inode.c

1526

btrfs_err(trans->fs_info,

fs/btrfs/delayed-inode.c

1648

btrfs_err(trans->fs_info,

fs/btrfs/delayed-inode.c

1658

btrfs_err(trans->fs_info,

fs/btrfs/delayed-inode.c

1957

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

fs/btrfs/delayed-inode.c

1966

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

fs/btrfs/delayed-inode.c

1975

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

fs/btrfs/delayed-inode.c

1999

atomic_inc(&fs_info->delayed_root.items);

fs/btrfs/delayed-inode.c

2009

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delayed-inode.c

2037

btrfs_delayed_inode_release_metadata(fs_info, delayed_node, false);

fs/btrfs/delayed-inode.c

2100

void btrfs_destroy_delayed_inodes(struct btrfs_fs_info *fs_info)

fs/btrfs/delayed-inode.c

2105

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

603

ret = btrfs_block_rsv_add(fs_info, dst_rsv, num_bytes,

fs/btrfs/delayed-inode.c

614

trace_btrfs_space_reservation(fs_info, "delayed_inode",

fs/btrfs/delayed-inode.c

622

static void btrfs_delayed_inode_release_metadata(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-inode.c

631

rsv = &fs_info->delayed_block_rsv;

fs/btrfs/delayed-inode.c

632

trace_btrfs_space_reservation(fs_info, "delayed_inode",

fs/btrfs/delayed-inode.c

634

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

fs/btrfs/delayed-inode.c

659

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delayed-inode.c

664

const int max_size = BTRFS_LEAF_DATA_SIZE(fs_info);

fs/btrfs/delayed-inode.c

684

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

fs/btrfs/delayed-inode.c

846

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/delayed-inode.c

904

trace_btrfs_space_reservation(fs_info, "delayed_item", ino,

fs/btrfs/delayed-inode.c

906

btrfs_block_rsv_release(fs_info, &fs_info->delayed_block_rsv,

fs/btrfs/delayed-inode.c

984

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

fs/btrfs/delayed-inode.c

993

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

1004

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-ref.c

1010

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

fs/btrfs/delayed-ref.c

1029

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

fs/btrfs/delayed-ref.c

1049

init_delayed_ref_common(fs_info, node, generic_ref);

fs/btrfs/delayed-ref.c

1087

trace_add_delayed_data_ref(trans->fs_info, node);

fs/btrfs/delayed-ref.c

1089

trace_add_delayed_tree_ref(trans->fs_info, node);

fs/btrfs/delayed-ref.c

1135

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

fs/btrfs/delayed-ref.c

1195

btrfs_find_delayed_ref_head(const struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

1199

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

fs/btrfs/delayed-ref.c

1276

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-ref.c

1296

drop_delayed_ref(fs_info, delayed_refs, head, ref);

fs/btrfs/delayed-ref.c

1301

btrfs_delete_ref_head(fs_info, delayed_refs, head);

fs/btrfs/delayed-ref.c

1306

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

fs/btrfs/delayed-ref.c

1309

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

fs/btrfs/delayed-ref.c

1317

btrfs_err(fs_info,

fs/btrfs/delayed-ref.c

1334

btrfs_error_unpin_extent_range(fs_info, head->bytenr,

fs/btrfs/delayed-ref.c

1337

if (!btrfs_is_testing(fs_info))

fs/btrfs/delayed-ref.c

1338

btrfs_cleanup_ref_head_accounting(fs_info, delayed_refs, head);

fs/btrfs/delayed-ref.c

1344

if (!btrfs_is_testing(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

137

struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;

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

210

int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_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

215

u64 limit = btrfs_calc_delayed_ref_bytes(fs_info, 1);

fs/btrfs/delayed-ref.c

263

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

370

static inline void drop_delayed_ref(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

381

btrfs_delayed_refs_rsv_release(fs_info, 1, 0);

fs/btrfs/delayed-ref.c

384

static bool merge_ref(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

414

drop_delayed_ref(fs_info, delayed_refs, head, next);

fs/btrfs/delayed-ref.c

417

drop_delayed_ref(fs_info, delayed_refs, head, ref);

fs/btrfs/delayed-ref.c

431

void btrfs_merge_delayed_refs(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

448

seq = btrfs_tree_mod_log_lowest_seq(fs_info);

fs/btrfs/delayed-ref.c

455

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

fs/btrfs/delayed-ref.c

460

int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info, u64 seq)

fs/btrfs/delayed-ref.c

463

u64 min_seq = btrfs_tree_mod_log_lowest_seq(fs_info);

fs/btrfs/delayed-ref.c

466

btrfs_debug(fs_info,

fs/btrfs/delayed-ref.c

476

const struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

487

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

fs/btrfs/delayed-ref.c

533

void btrfs_delete_ref_head(const struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

537

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

fs/btrfs/delayed-ref.c

625

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

fs/btrfs/delayed-ref.c

640

struct btrfs_fs_info *fs_info = trans->fs_info;

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

68

struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/delayed-ref.c

709

btrfs_csum_bytes_to_leaves(fs_info,

fs/btrfs/delayed-ref.c

714

btrfs_delayed_refs_rsv_release(fs_info, 0, csum_leaves);

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

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

817

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/delayed-ref.c

820

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

fs/btrfs/delayed-ref.c

837

btrfs_err_rl(fs_info,

fs/btrfs/delayed-ref.c

840

btrfs_err_32bit_limit(fs_info);

fs/btrfs/delayed-ref.c

855

ret = btrfs_qgroup_trace_extent_nolock(fs_info, delayed_refs, qrecord,

fs/btrfs/delayed-ref.c

867

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

901

btrfs_csum_bytes_to_leaves(fs_info, head_ref->num_bytes);

fs/btrfs/delayed-ref.c

91

struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/delayed-ref.c

934

static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,

fs/btrfs/delayed-ref.c

945

seq = atomic64_read(&fs_info->tree_mod_seq);

fs/btrfs/delayed-ref.c

96

if (btrfs_is_testing(fs_info))

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

1005

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

1012

btrfs_scratch_superblocks(fs_info, src_device);

fs/btrfs/dev-replace.c

102

btrfs_err(fs_info,

fs/btrfs/dev-replace.c

1031

static u64 btrfs_dev_replace_progress(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

1033

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

1055

void btrfs_dev_replace_status(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

1058

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

1071

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

fs/btrfs/dev-replace.c

1075

int btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

1077

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

1081

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/dev-replace.c

1085

if (sb_rdonly(fs_info->sb))

fs/btrfs/dev-replace.c

1101

ret = btrfs_scrub_cancel(fs_info);

fs/btrfs/dev-replace.c

1110

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

1134

btrfs_scrub_cancel(fs_info);

fs/btrfs/dev-replace.c

1144

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

1161

void btrfs_dev_replace_suspend_for_unmount(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

1163

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

1179

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

fs/btrfs/dev-replace.c

1188

int btrfs_resume_dev_replace_async(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

1191

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

1209

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

1211

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

1225

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_DEV_REPLACE)) {

fs/btrfs/dev-replace.c

1230

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

1235

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

fs/btrfs/dev-replace.c

1241

struct btrfs_fs_info *fs_info = data;

fs/btrfs/dev-replace.c

1242

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

1246

progress = btrfs_dev_replace_progress(fs_info);

fs/btrfs/dev-replace.c

1248

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

1255

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

fs/btrfs/dev-replace.c

1259

ret = btrfs_dev_replace_finishing(fs_info, ret);

fs/btrfs/dev-replace.c

1262

btrfs_exclop_finish(fs_info);

fs/btrfs/dev-replace.c

1293

void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount)

fs/btrfs/dev-replace.c

1295

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

fs/btrfs/dev-replace.c

1296

cond_wake_up_nomb(&fs_info->dev_replace.replace_wait);

fs/btrfs/dev-replace.c

1299

void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

130

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

1302

percpu_counter_inc(&fs_info->dev_replace.bio_counter);

fs/btrfs/dev-replace.c

1304

&fs_info->fs_state)))

fs/btrfs/dev-replace.c

1307

btrfs_bio_counter_dec(fs_info);

fs/btrfs/dev-replace.c

1308

wait_event(fs_info->dev_replace.replace_wait,

fs/btrfs/dev-replace.c

1310

&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

338

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/dev-replace.c

340

struct btrfs_root *dev_root = fs_info->dev_root;

fs/btrfs/dev-replace.c

345

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

365

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

386

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

400

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

438

static int mark_block_group_to_copy(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

444

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/dev-replace.c

453

if (!btrfs_is_zoned(fs_info))

fs/btrfs/dev-replace.c

456

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

459

spin_lock(&fs_info->trans_lock);

fs/btrfs/dev-replace.c

460

while (fs_info->running_transaction &&

fs/btrfs/dev-replace.c

461

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

fs/btrfs/dev-replace.c

462

spin_unlock(&fs_info->trans_lock);

fs/btrfs/dev-replace.c

463

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

467

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

469

spin_lock(&fs_info->trans_lock);

fs/btrfs/dev-replace.c

477

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

481

spin_lock(&fs_info->trans_lock);

fs/btrfs/dev-replace.c

483

spin_unlock(&fs_info->trans_lock);

fs/btrfs/dev-replace.c

515

cache = btrfs_lookup_block_group(fs_info, chunk_offset);

fs/btrfs/dev-replace.c

527

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

536

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/dev-replace.c

543

if (!btrfs_is_zoned(fs_info))

fs/btrfs/dev-replace.c

553

map = btrfs_get_chunk_map(fs_info, chunk_offset, 1);

fs/btrfs/dev-replace.c

584

static int btrfs_dev_replace_start(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

588

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/dev-replace.c

590

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

595

src_device = btrfs_find_device_by_devspec(fs_info, srcdevid,

fs/btrfs/dev-replace.c

600

if (btrfs_pinned_by_swapfile(fs_info, src_device)) {

fs/btrfs/dev-replace.c

601

btrfs_warn(fs_info,

fs/btrfs/dev-replace.c

620

ret = btrfs_init_dev_replace_tgtdev(fs_info, tgtdev_name,

fs/btrfs/dev-replace.c

625

ret = mark_block_group_to_copy(fs_info, src_device);

fs/btrfs/dev-replace.c

648

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

672

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

fs/btrfs/dev-replace.c

674

btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);

fs/btrfs/dev-replace.c

698

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

fs/btrfs/dev-replace.c

70

int btrfs_init_dev_replace(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

702

ret = btrfs_dev_replace_finishing(fs_info, ret);

fs/btrfs/dev-replace.c

730

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

746

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

762

static void btrfs_rm_dev_replace_blocked(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

764

set_bit(BTRFS_FS_STATE_DEV_REPLACING, &fs_info->fs_state);

fs/btrfs/dev-replace.c

765

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

fs/btrfs/dev-replace.c

766

&fs_info->dev_replace.bio_counter));

fs/btrfs/dev-replace.c

772

static void btrfs_rm_dev_replace_unblocked(struct btrfs_fs_info *fs_info)

fs/btrfs/dev-replace.c

774

clear_bit(BTRFS_FS_STATE_DEV_REPLACING, &fs_info->fs_state);

fs/btrfs/dev-replace.c

775

wake_up(&fs_info->dev_replace.replace_wait);

fs/btrfs/dev-replace.c

793

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

fs/btrfs/dev-replace.c

810

struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

822

lockdep_assert_held(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

824

write_lock(&fs_info->mapping_tree_lock);

fs/btrfs/dev-replace.c

825

node = rb_first_cached(&fs_info->mapping_tree);

fs/btrfs/dev-replace.c

838

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

fs/btrfs/dev-replace.c

839

map = btrfs_find_chunk_map_nolock(fs_info, next_start, U64_MAX);

fs/btrfs/dev-replace.c

853

write_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/dev-replace.c

856

static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,

fs/btrfs/dev-replace.c

859

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/dev-replace.c

860

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/dev-replace.c

863

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/dev-replace.c

888

ret = btrfs_start_delalloc_roots(fs_info, LONG_MAX, false);

fs/btrfs/dev-replace.c

893

btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);

fs/btrfs/dev-replace.c

912

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

916

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

939

btrfs_dev_replace_update_device_in_mapping_tree(fs_info,

fs/btrfs/dev-replace.c

944

btrfs_err(fs_info,

fs/btrfs/dev-replace.c

951

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/dev-replace.c

953

btrfs_rm_dev_replace_blocked(fs_info);

fs/btrfs/dev-replace.c

956

btrfs_rm_dev_replace_unblocked(fs_info);

fs/btrfs/dev-replace.c

962

btrfs_info(fs_info,

fs/btrfs/dev-replace.c

986

btrfs_rm_dev_replace_blocked(fs_info);

fs/btrfs/dev-replace.c

990

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

272

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

1001

static int check_direct_read(struct btrfs_fs_info *fs_info,

fs/btrfs/direct-io.c

1007

ret = check_direct_IO(fs_info, iter, offset);

fs/btrfs/direct-io.c

179

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/direct-io.c

188

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

fs/btrfs/direct-io.c

191

ASSERT(btrfs_is_zoned(fs_info));

fs/btrfs/direct-io.c

192

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

fs/btrfs/direct-io.c

207

btrfs_dec_block_group_reservations(fs_info, ins.objectid);

fs/btrfs/direct-io.c

209

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

fs/btrfs/direct-io.c

221

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/direct-io.c

254

bg = btrfs_inc_nocow_writers(fs_info, block_start);

fs/btrfs/direct-io.c

360

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/direct-io.c

390

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

fs/btrfs/direct-io.c

566

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

fs/btrfs/direct-io.c

653

btrfs_warn(inode->root->fs_info,

fs/btrfs/direct-io.c

778

static ssize_t check_direct_IO(struct btrfs_fs_info *fs_info,

fs/btrfs/direct-io.c

781

const u32 blocksize_mask = fs_info->sectorsize - 1;

fs/btrfs/direct-io.c

795

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/direct-io.c

804

const u64 data_profile = btrfs_data_alloc_profile(fs_info) &

fs/btrfs/direct-io.c

865

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

1006

if (unlikely(!btrfs_is_testing(fs_info) &&

fs/btrfs/disk-io.c

1010

btrfs_crit(fs_info,

fs/btrfs/disk-io.c

1088

static struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1093

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

1094

root = radix_tree_lookup(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

1097

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

1101

static struct btrfs_root *btrfs_get_global_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1112

return btrfs_grab_root(fs_info->tree_root);

fs/btrfs/disk-io.c

1114

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

fs/btrfs/disk-io.c

1116

return btrfs_grab_root(fs_info->chunk_root);

fs/btrfs/disk-io.c

1118

return btrfs_grab_root(fs_info->dev_root);

fs/btrfs/disk-io.c

1120

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

fs/btrfs/disk-io.c

1122

return btrfs_grab_root(fs_info->quota_root);

fs/btrfs/disk-io.c

1124

return btrfs_grab_root(fs_info->uuid_root);

fs/btrfs/disk-io.c

1126

return btrfs_grab_root(fs_info->block_group_root);

fs/btrfs/disk-io.c

1128

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

fs/btrfs/disk-io.c

1130

return btrfs_grab_root(fs_info->stripe_root);

fs/btrfs/disk-io.c

1132

return btrfs_grab_root(fs_info->remap_root);

fs/btrfs/disk-io.c

1138

int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1147

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

1148

ret = radix_tree_insert(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

1155

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

1161

void btrfs_check_leaked_roots(const struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1166

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

fs/btrfs/disk-io.c

1169

root = list_first_entry(&fs_info->allocated_roots,

fs/btrfs/disk-io.c

1171

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

fs/btrfs/disk-io.c

1182

static void free_global_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1187

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

fs/btrfs/disk-io.c

1189

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

fs/btrfs/disk-io.c

1194

void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1196

struct percpu_counter *em_counter = &fs_info->evictable_extent_maps;

fs/btrfs/disk-io.c

1198

if (fs_info->fs_devices)

fs/btrfs/disk-io.c

1199

btrfs_close_devices(fs_info->fs_devices);

fs/btrfs/disk-io.c

1200

btrfs_free_compress_wsm(fs_info);

fs/btrfs/disk-io.c

1201

percpu_counter_destroy(&fs_info->stats_read_blocks);

fs/btrfs/disk-io.c

1202

percpu_counter_destroy(&fs_info->dirty_metadata_bytes);

fs/btrfs/disk-io.c

1203

percpu_counter_destroy(&fs_info->delalloc_bytes);

fs/btrfs/disk-io.c

1204

percpu_counter_destroy(&fs_info->ordered_bytes);

fs/btrfs/disk-io.c

1208

percpu_counter_destroy(&fs_info->dev_replace.bio_counter);

fs/btrfs/disk-io.c

1209

btrfs_free_stripe_hash_table(fs_info);

fs/btrfs/disk-io.c

1210

btrfs_free_ref_cache(fs_info);

fs/btrfs/disk-io.c

1211

kfree(fs_info->balance_ctl);

fs/btrfs/disk-io.c

1212

free_global_roots(fs_info);

fs/btrfs/disk-io.c

1213

btrfs_put_root(fs_info->tree_root);

fs/btrfs/disk-io.c

1214

btrfs_put_root(fs_info->chunk_root);

fs/btrfs/disk-io.c

1215

btrfs_put_root(fs_info->dev_root);

fs/btrfs/disk-io.c

1216

btrfs_put_root(fs_info->quota_root);

fs/btrfs/disk-io.c

1217

btrfs_put_root(fs_info->uuid_root);

fs/btrfs/disk-io.c

1218

btrfs_put_root(fs_info->fs_root);

fs/btrfs/disk-io.c

1219

btrfs_put_root(fs_info->data_reloc_root);

fs/btrfs/disk-io.c

1220

btrfs_put_root(fs_info->block_group_root);

fs/btrfs/disk-io.c

1221

btrfs_put_root(fs_info->stripe_root);

fs/btrfs/disk-io.c

1222

btrfs_put_root(fs_info->remap_root);

fs/btrfs/disk-io.c

1223

btrfs_check_leaked_roots(fs_info);

fs/btrfs/disk-io.c

1224

btrfs_extent_buffer_leak_debug_check(fs_info);

fs/btrfs/disk-io.c

1225

kfree(fs_info->super_copy);

fs/btrfs/disk-io.c

1226

kfree(fs_info->super_for_commit);

fs/btrfs/disk-io.c

1227

kvfree(fs_info);

fs/btrfs/disk-io.c

1249

static struct btrfs_root *btrfs_get_root_ref(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1258

root = btrfs_get_global_root(fs_info, objectid);

fs/btrfs/disk-io.c

126

btrfs_err_rl(eb->fs_info,

fs/btrfs/disk-io.c

1272

root = btrfs_lookup_fs_root(fs_info, objectid);

fs/btrfs/disk-io.c

1295

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

fs/btrfs/disk-io.c

1317

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

fs/btrfs/disk-io.c

1324

ret = btrfs_insert_fs_root(fs_info, root);

fs/btrfs/disk-io.c

1353

struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1356

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

fs/btrfs/disk-io.c

1367

struct btrfs_root *btrfs_get_new_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1370

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

fs/btrfs/disk-io.c

1388

struct btrfs_root *btrfs_get_fs_root_commit_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1403

root = btrfs_get_global_root(fs_info, objectid);

fs/btrfs/disk-io.c

1407

root = btrfs_lookup_fs_root(fs_info, objectid);

fs/btrfs/disk-io.c

1414

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

fs/btrfs/disk-io.c

1422

struct btrfs_fs_info *fs_info = arg;

fs/btrfs/disk-io.c

1428

set_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags);

fs/btrfs/disk-io.c

1431

if (btrfs_need_cleaner_sleep(fs_info))

fs/btrfs/disk-io.c

1438

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

fs/btrfs/disk-io.c

1441

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

fs/btrfs/disk-io.c

1448

if (btrfs_need_cleaner_sleep(fs_info)) {

fs/btrfs/disk-io.c

1449

mutex_unlock(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

1453

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

fs/btrfs/disk-io.c

1454

btrfs_sysfs_feature_update(fs_info);

fs/btrfs/disk-io.c

1456

btrfs_run_delayed_iputs(fs_info);

fs/btrfs/disk-io.c

1458

again = btrfs_clean_one_deleted_snapshot(fs_info);

fs/btrfs/disk-io.c

1459

mutex_unlock(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

1465

btrfs_run_defrag_inodes(fs_info);

fs/btrfs/disk-io.c

1467

if (btrfs_fs_incompat(fs_info, REMAP_TREE) &&

fs/btrfs/disk-io.c

1468

!btrfs_test_opt(fs_info, DISCARD_ASYNC))

fs/btrfs/disk-io.c

1469

btrfs_handle_fully_remapped_bgs(fs_info);

fs/btrfs/disk-io.c

1479

btrfs_delete_unused_bgs(fs_info);

fs/btrfs/disk-io.c

1486

btrfs_reclaim_bgs(fs_info);

fs/btrfs/disk-io.c

1488

clear_and_wake_up_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags);

fs/btrfs/disk-io.c

1504

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/disk-io.c

1514

delay = secs_to_jiffies(fs_info->commit_interval);

fs/btrfs/disk-io.c

1515

mutex_lock(&fs_info->transaction_kthread_mutex);

fs/btrfs/disk-io.c

1517

spin_lock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

1518

cur = fs_info->running_transaction;

fs/btrfs/disk-io.c

1520

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

1525

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

fs/btrfs/disk-io.c

1527

delta < fs_info->commit_interval) {

fs/btrfs/disk-io.c

1528

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

153

int btrfs_check_super_csum(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

1531

secs_to_jiffies(fs_info->commit_interval));

fs/btrfs/disk-io.c

1535

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

1550

wake_up_process(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

1551

mutex_unlock(&fs_info->transaction_kthread_mutex);

fs/btrfs/disk-io.c

1553

if (BTRFS_FS_ERROR(fs_info))

fs/btrfs/disk-io.c

1554

btrfs_cleanup_transaction(fs_info);

fs/btrfs/disk-io.c

1556

(!btrfs_transaction_blocked(fs_info) ||

fs/btrfs/disk-io.c

163

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

fs/btrfs/disk-io.c

166

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

fs/btrfs/disk-io.c

1695

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

fs/btrfs/disk-io.c

1697

int backup_index = find_newest_super_backup(fs_info);

fs/btrfs/disk-io.c

1698

struct btrfs_super_block *super = fs_info->super_copy;

fs/btrfs/disk-io.c

1731

static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1733

btrfs_destroy_workqueue(fs_info->fixup_workers);

fs/btrfs/disk-io.c

1734

btrfs_destroy_workqueue(fs_info->delalloc_workers);

fs/btrfs/disk-io.c

1735

btrfs_destroy_workqueue(fs_info->workers);

fs/btrfs/disk-io.c

1736

if (fs_info->endio_workers)

fs/btrfs/disk-io.c

1737

destroy_workqueue(fs_info->endio_workers);

fs/btrfs/disk-io.c

1738

if (fs_info->rmw_workers)

fs/btrfs/disk-io.c

1739

destroy_workqueue(fs_info->rmw_workers);

fs/btrfs/disk-io.c

1740

btrfs_destroy_workqueue(fs_info->endio_write_workers);

fs/btrfs/disk-io.c

1741

btrfs_destroy_workqueue(fs_info->endio_freespace_worker);

fs/btrfs/disk-io.c

1742

btrfs_destroy_workqueue(fs_info->delayed_workers);

fs/btrfs/disk-io.c

1743

btrfs_destroy_workqueue(fs_info->caching_workers);

fs/btrfs/disk-io.c

1744

btrfs_destroy_workqueue(fs_info->flush_workers);

fs/btrfs/disk-io.c

1745

btrfs_destroy_workqueue(fs_info->qgroup_rescan_workers);

fs/btrfs/disk-io.c

1746

if (fs_info->discard_ctl.discard_workers)

fs/btrfs/disk-io.c

1747

destroy_workqueue(fs_info->discard_ctl.discard_workers);

fs/btrfs/disk-io.c

175

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/disk-io.c

1753

if (fs_info->endio_meta_workers)

fs/btrfs/disk-io.c

1754

destroy_workqueue(fs_info->endio_meta_workers);

fs/btrfs/disk-io.c

176

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

fs/btrfs/disk-io.c

1767

static void free_global_root_pointers(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1772

&fs_info->global_root_tree,

fs/btrfs/disk-io.c

180

if (sb_rdonly(fs_info->sb))

fs/btrfs/disk-io.c

1810

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

fs/btrfs/disk-io.c

1812

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

fs/btrfs/disk-io.c

1818

void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1824

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

fs/btrfs/disk-io.c

1825

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

fs/btrfs/disk-io.c

1830

btrfs_drop_and_free_fs_root(fs_info, gang[0]);

fs/btrfs/disk-io.c

1835

ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

1841

btrfs_drop_and_free_fs_root(fs_info, gang[i]);

fs/btrfs/disk-io.c

1845

static void btrfs_init_scrub(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1847

mutex_init(&fs_info->scrub_lock);

fs/btrfs/disk-io.c

1848

atomic_set(&fs_info->scrubs_running, 0);

fs/btrfs/disk-io.c

1849

atomic_set(&fs_info->scrub_pause_req, 0);

fs/btrfs/disk-io.c

1850

atomic_set(&fs_info->scrubs_paused, 0);

fs/btrfs/disk-io.c

1851

atomic_set(&fs_info->scrub_cancel_req, 0);

fs/btrfs/disk-io.c

1852

init_waitqueue_head(&fs_info->scrub_pause_wait);

fs/btrfs/disk-io.c

1853

refcount_set(&fs_info->scrub_workers_refcnt, 0);

fs/btrfs/disk-io.c

1856

static void btrfs_init_balance(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1858

spin_lock_init(&fs_info->balance_lock);

fs/btrfs/disk-io.c

1859

mutex_init(&fs_info->balance_mutex);

fs/btrfs/disk-io.c

1860

atomic_set(&fs_info->balance_pause_req, 0);

fs/btrfs/disk-io.c

1861

atomic_set(&fs_info->balance_cancel_req, 0);

fs/btrfs/disk-io.c

1862

fs_info->balance_ctl = NULL;

fs/btrfs/disk-io.c

1863

init_waitqueue_head(&fs_info->balance_wait_q);

fs/btrfs/disk-io.c

1864

atomic_set(&fs_info->reloc_cancel_req, 0);

fs/btrfs/disk-io.c

1869

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/disk-io.c

1871

fs_info->tree_root);

fs/btrfs/disk-io.c

1889

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

fs/btrfs/disk-io.c

1893

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

fs/btrfs/disk-io.c

1897

fs_info->btree_inode = inode;

fs/btrfs/disk-io.c

1902

static void btrfs_init_dev_replace_locks(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1904

mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);

fs/btrfs/disk-io.c

1905

init_rwsem(&fs_info->dev_replace.rwsem);

fs/btrfs/disk-io.c

1906

init_waitqueue_head(&fs_info->dev_replace.replace_wait);

fs/btrfs/disk-io.c

1909

static void btrfs_init_qgroup(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1911

spin_lock_init(&fs_info->qgroup_lock);

fs/btrfs/disk-io.c

1912

mutex_init(&fs_info->qgroup_ioctl_lock);

fs/btrfs/disk-io.c

1913

fs_info->qgroup_tree = RB_ROOT;

fs/btrfs/disk-io.c

1914

INIT_LIST_HEAD(&fs_info->dirty_qgroups);

fs/btrfs/disk-io.c

1915

fs_info->qgroup_seq = 1;

fs/btrfs/disk-io.c

1916

fs_info->qgroup_rescan_running = false;

fs/btrfs/disk-io.c

1917

fs_info->qgroup_drop_subtree_thres = BTRFS_QGROUP_DROP_SUBTREE_THRES_DEFAULT;

fs/btrfs/disk-io.c

1918

mutex_init(&fs_info->qgroup_rescan_lock);

fs/btrfs/disk-io.c

1921

static int btrfs_init_workqueues(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

1923

u32 max_active = fs_info->thread_pool_size;

fs/btrfs/disk-io.c

1927

fs_info->workers =

fs/btrfs/disk-io.c

1928

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

fs/btrfs/disk-io.c

1930

fs_info->delalloc_workers =

fs/btrfs/disk-io.c

1931

btrfs_alloc_workqueue(fs_info, "delalloc",

fs/btrfs/disk-io.c

1934

fs_info->flush_workers =

fs/btrfs/disk-io.c

1935

btrfs_alloc_workqueue(fs_info, "flush_delalloc",

fs/btrfs/disk-io.c

1938

fs_info->caching_workers =

fs/btrfs/disk-io.c

1939

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

fs/btrfs/disk-io.c

1941

fs_info->fixup_workers =

fs/btrfs/disk-io.c

1942

btrfs_alloc_ordered_workqueue(fs_info, "fixup", ordered_flags);

fs/btrfs/disk-io.c

1944

fs_info->endio_workers =

fs/btrfs/disk-io.c

1946

fs_info->endio_meta_workers =

fs/btrfs/disk-io.c

1948

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

fs/btrfs/disk-io.c

1949

fs_info->endio_write_workers =

fs/btrfs/disk-io.c

1950

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

fs/btrfs/disk-io.c

1952

fs_info->endio_freespace_worker =

fs/btrfs/disk-io.c

1953

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

fs/btrfs/disk-io.c

1955

fs_info->delayed_workers =

fs/btrfs/disk-io.c

1956

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

fs/btrfs/disk-io.c

1958

fs_info->qgroup_rescan_workers =

fs/btrfs/disk-io.c

1959

btrfs_alloc_ordered_workqueue(fs_info, "qgroup-rescan",

fs/btrfs/disk-io.c

1961

fs_info->discard_ctl.discard_workers =

fs/btrfs/disk-io.c

1964

if (!(fs_info->workers &&

fs/btrfs/disk-io.c

1965

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

fs/btrfs/disk-io.c

1966

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

fs/btrfs/disk-io.c

1967

fs_info->endio_write_workers &&

fs/btrfs/disk-io.c

1968

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

fs/btrfs/disk-io.c

1969

fs_info->caching_workers && fs_info->fixup_workers &&

fs/btrfs/disk-io.c

1970

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

fs/btrfs/disk-io.c

1971

fs_info->discard_ctl.discard_workers)) {

fs/btrfs/disk-io.c

1978

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

fs/btrfs/disk-io.c

1984

set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);

fs/btrfs/disk-io.c

1987

set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);

fs/btrfs/disk-io.c

1993

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

fs/btrfs/disk-io.c

1997

static int btrfs_replay_log(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

200

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

fs/btrfs/disk-io.c

2003

struct btrfs_super_block *disk_super = fs_info->super_copy;

fs/btrfs/disk-io.c

2008

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

fs/btrfs/disk-io.c

2012

log_tree_root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID,

fs/btrfs/disk-io.c

2018

check.transid = fs_info->generation + 1;

fs/btrfs/disk-io.c

2020

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

fs/btrfs/disk-io.c

2024

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

fs/btrfs/disk-io.c

2029

btrfs_err(fs_info, "failed to read log tree");

fs/btrfs/disk-io.c

2038

ASSERT(BTRFS_FS_ERROR(fs_info) != 0);

fs/btrfs/disk-io.c

2039

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

fs/btrfs/disk-io.c

2043

if (sb_rdonly(fs_info->sb)) {

fs/btrfs/disk-io.c

2044

ret = btrfs_commit_super(fs_info);

fs/btrfs/disk-io.c

2056

struct btrfs_fs_info *fs_info = tree_root->fs_info;

fs/btrfs/disk-io.c

2069

btrfs_test_opt(fs_info, IGNOREDATACSUMS)) {

fs/btrfs/disk-io.c

2070

set_bit(BTRFS_FS_STATE_NO_DATA_CSUMS, &fs_info->fs_state);

fs/btrfs/disk-io.c

2118

fs_info->nr_global_roots = max_global_id + 1;

fs/btrfs/disk-io.c

2122

set_bit(BTRFS_FS_STATE_NO_DATA_CSUMS, &fs_info->fs_state);

fs/btrfs/disk-io.c

2124

if (!btrfs_test_opt(fs_info, IGNOREBADROOTS))

fs/btrfs/disk-io.c

2128

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

fs/btrfs/disk-io.c

214

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/disk-io.c

2150

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

fs/btrfs/disk-io.c

2158

static int btrfs_read_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

2160

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/disk-io.c

2165

ASSERT(fs_info->tree_root);

fs/btrfs/disk-io.c

2174

if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE)) {

fs/btrfs/disk-io.c

2178

if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {

fs/btrfs/disk-io.c

2184

fs_info->block_group_root = root;

fs/btrfs/disk-io.c

2191

if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {

fs/btrfs/disk-io.c

2197

fs_info->dev_root = root;

fs/btrfs/disk-io.c

2200

ret = btrfs_init_devices_late(fs_info);

fs/btrfs/disk-io.c

2204

if (btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/disk-io.c

2206

root = fs_info->remap_root;

fs/btrfs/disk-io.c

2216

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

fs/btrfs/disk-io.c

2218

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

fs/btrfs/disk-io.c

2222

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

fs/btrfs/disk-io.c

2230

root = btrfs_get_fs_root(tree_root->fs_info,

fs/btrfs/disk-io.c

2233

if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {

fs/btrfs/disk-io.c

2240

fs_info->data_reloc_root = root;

fs/btrfs/disk-io.c

2248

fs_info->quota_root = root;

fs/btrfs/disk-io.c

2254

if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {

fs/btrfs/disk-io.c

2261

fs_info->uuid_root = root;

fs/btrfs/disk-io.c

2264

if (btrfs_fs_incompat(fs_info, RAID_STRIPE_TREE)) {

fs/btrfs/disk-io.c

2268

if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {

fs/btrfs/disk-io.c

2274

fs_info->stripe_root = root;

fs/btrfs/disk-io.c

228

num_copies = btrfs_num_copies(fs_info,

fs/btrfs/disk-io.c

2280

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

fs/btrfs/disk-io.c

2285

static int validate_sys_chunk_array(const struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

2297

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

fs/btrfs/disk-io.c

2320

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2331

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2336

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

fs/btrfs/disk-io.c

2344

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2360

int btrfs_validate_super(const struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

2366

const bool ignore_flags = btrfs_test_opt(fs_info, IGNORESUPERFLAGS);

fs/btrfs/disk-io.c

2369

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

fs/btrfs/disk-io.c

2374

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2379

btrfs_info(fs_info,

fs/btrfs/disk-io.c

2385

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

fs/btrfs/disk-io.c

2390

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

fs/btrfs/disk-io.c

2395

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

fs/btrfs/disk-io.c

2406

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

fs/btrfs/disk-io.c

2411

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2419

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

fs/btrfs/disk-io.c

2423

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

fs/btrfs/disk-io.c

2430

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

fs/btrfs/disk-io.c

2435

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

fs/btrfs/disk-io.c

2440

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

fs/btrfs/disk-io.c

2445

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

fs/btrfs/disk-io.c

2446

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

fs/btrfs/disk-io.c

2447

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2449

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

fs/btrfs/disk-io.c

2453

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

fs/btrfs/disk-io.c

2455

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2457

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

fs/btrfs/disk-io.c

2461

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

fs/btrfs/disk-io.c

2463

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2465

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

fs/btrfs/disk-io.c

2473

if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE) &&

fs/btrfs/disk-io.c

2474

(!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID) ||

fs/btrfs/disk-io.c

2475

!btrfs_fs_incompat(fs_info, NO_HOLES))) {

fs/btrfs/disk-io.c

2476

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2481

if (btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/disk-io.c

2486

if (!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID) ||

fs/btrfs/disk-io.c

2487

!btrfs_fs_incompat(fs_info, NO_HOLES) ||

fs/btrfs/disk-io.c

2488

!btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE)) {

fs/btrfs/disk-io.c

2489

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2494

if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {

fs/btrfs/disk-io.c

2495

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

fs/btrfs/disk-io.c

2499

if (btrfs_fs_incompat(fs_info, ZONED)) {

fs/btrfs/disk-io.c

2500

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

fs/btrfs/disk-io.c

2505

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

fs/btrfs/disk-io.c

2515

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

fs/btrfs/disk-io.c

2520

btrfs_err(fs_info, "invalid stripesize %u",

fs/btrfs/disk-io.c

2525

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

fs/btrfs/disk-io.c

2528

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

fs/btrfs/disk-io.c

2534

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

fs/btrfs/disk-io.c

2542

ret = validate_sys_chunk_array(fs_info, sb);

fs/btrfs/disk-io.c

2549

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

fs/btrfs/disk-io.c

2556

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

fs/btrfs/disk-io.c

2568

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

2574

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

258

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/disk-io.c

2587

static int btrfs_validate_mount_super(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

2589

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

fs/btrfs/disk-io.c

2598

static int btrfs_validate_write_super(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

2603

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

fs/btrfs/disk-io.c

2608

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

fs/btrfs/disk-io.c

2614

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2622

btrfs_err(fs_info,

fs/btrfs/disk-io.c

2636

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

fs/btrfs/disk-io.c

2654

static int load_important_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

2656

struct btrfs_super_block *sb = fs_info->super_copy;

fs/btrfs/disk-io.c

2663

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

fs/btrfs/disk-io.c

2665

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

fs/btrfs/disk-io.c

2669

if (btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/disk-io.c

2673

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

fs/btrfs/disk-io.c

2675

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

fs/btrfs/disk-io.c

2683

static int __cold init_tree_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

2685

int backup_index = find_newest_super_backup(fs_info);

fs/btrfs/disk-io.c

2686

struct btrfs_super_block *sb = fs_info->super_copy;

fs/btrfs/disk-io.c

2687

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/disk-io.c

2698

if (!btrfs_test_opt(fs_info, USEBACKUPROOT))

fs/btrfs/disk-io.c

2701

free_root_pointers(fs_info, 0);

fs/btrfs/disk-io.c

2709

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

fs/btrfs/disk-io.c

2710

ret = read_backup_root(fs_info, i);

fs/btrfs/disk-io.c

2716

ret = load_important_roots(fs_info);

fs/btrfs/disk-io.c

2734

ret = btrfs_read_roots(fs_info);

fs/btrfs/disk-io.c

2741

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

fs/btrfs/disk-io.c

2742

btrfs_set_last_trans_committed(fs_info, fs_info->generation);

fs/btrfs/disk-io.c

2743

fs_info->last_reloc_trans = 0;

fs/btrfs/disk-io.c

2747

fs_info->backup_root_index = 0;

fs/btrfs/disk-io.c

2749

fs_info->backup_root_index = backup_index + 1;

fs/btrfs/disk-io.c

2750

fs_info->backup_root_index %= BTRFS_NUM_BACKUP_ROOTS;

fs/btrfs/disk-io.c

2765

void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

2767

INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);

fs/btrfs/disk-io.c

2770

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

fs/btrfs/disk-io.c

2771

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

fs/btrfs/disk-io.c

2773

INIT_LIST_HEAD(&fs_info->trans_list);

fs/btrfs/disk-io.c

2774

INIT_LIST_HEAD(&fs_info->dead_roots);

fs/btrfs/disk-io.c

2775

INIT_LIST_HEAD(&fs_info->delayed_iputs);

fs/btrfs/disk-io.c

2776

INIT_LIST_HEAD(&fs_info->delalloc_roots);

fs/btrfs/disk-io.c

2777

INIT_LIST_HEAD(&fs_info->caching_block_groups);

fs/btrfs/disk-io.c

2778

spin_lock_init(&fs_info->delalloc_root_lock);

fs/btrfs/disk-io.c

2779

spin_lock_init(&fs_info->trans_lock);

fs/btrfs/disk-io.c

2780

spin_lock_init(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

2781

spin_lock_init(&fs_info->delayed_iput_lock);

fs/btrfs/disk-io.c

2782

spin_lock_init(&fs_info->defrag_inodes_lock);

fs/btrfs/disk-io.c

2783

spin_lock_init(&fs_info->super_lock);

fs/btrfs/disk-io.c

2784

spin_lock_init(&fs_info->unused_bgs_lock);

fs/btrfs/disk-io.c

2785

spin_lock_init(&fs_info->treelog_bg_lock);

fs/btrfs/disk-io.c

2786

spin_lock_init(&fs_info->zone_active_bgs_lock);

fs/btrfs/disk-io.c

2787

spin_lock_init(&fs_info->relocation_bg_lock);

fs/btrfs/disk-io.c

2788

rwlock_init(&fs_info->tree_mod_log_lock);

fs/btrfs/disk-io.c

2789

rwlock_init(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

2790

mutex_init(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/disk-io.c

2791

mutex_init(&fs_info->reclaim_bgs_lock);

fs/btrfs/disk-io.c

2792

mutex_init(&fs_info->reloc_mutex);

fs/btrfs/disk-io.c

2793

mutex_init(&fs_info->delalloc_root_mutex);

fs/btrfs/disk-io.c

2794

mutex_init(&fs_info->zoned_meta_io_lock);

fs/btrfs/disk-io.c

2795

mutex_init(&fs_info->zoned_data_reloc_io_lock);

fs/btrfs/disk-io.c

2796

seqlock_init(&fs_info->profiles_lock);

fs/btrfs/disk-io.c

2798

btrfs_lockdep_init_map(fs_info, btrfs_trans_num_writers);

fs/btrfs/disk-io.c

2799

btrfs_lockdep_init_map(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/disk-io.c

2800

btrfs_lockdep_init_map(fs_info, btrfs_trans_pending_ordered);

fs/btrfs/disk-io.c

2801

btrfs_lockdep_init_map(fs_info, btrfs_ordered_extent);

fs/btrfs/disk-io.c

2802

btrfs_state_lockdep_init_map(fs_info, btrfs_trans_commit_prep,

fs/btrfs/disk-io.c

2804

btrfs_state_lockdep_init_map(fs_info, btrfs_trans_unblocked,

fs/btrfs/disk-io.c

2806

btrfs_state_lockdep_init_map(fs_info, btrfs_trans_super_committed,

fs/btrfs/disk-io.c

2808

btrfs_state_lockdep_init_map(fs_info, btrfs_trans_completed,

fs/btrfs/disk-io.c

2811

INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);

fs/btrfs/disk-io.c

2812

INIT_LIST_HEAD(&fs_info->space_info);

fs/btrfs/disk-io.c

2813

INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);

fs/btrfs/disk-io.c

2814

INIT_LIST_HEAD(&fs_info->unused_bgs);

fs/btrfs/disk-io.c

2815

INIT_LIST_HEAD(&fs_info->reclaim_bgs);

fs/btrfs/disk-io.c

2816

INIT_LIST_HEAD(&fs_info->fully_remapped_bgs);

fs/btrfs/disk-io.c

2817

INIT_LIST_HEAD(&fs_info->zone_active_bgs);

fs/btrfs/disk-io.c

2819

INIT_LIST_HEAD(&fs_info->allocated_roots);

fs/btrfs/disk-io.c

2820

INIT_LIST_HEAD(&fs_info->allocated_ebs);

fs/btrfs/disk-io.c

2821

spin_lock_init(&fs_info->eb_leak_lock);

fs/btrfs/disk-io.c

2823

fs_info->mapping_tree = RB_ROOT_CACHED;

fs/btrfs/disk-io.c

2824

rwlock_init(&fs_info->mapping_tree_lock);

fs/btrfs/disk-io.c

2825

btrfs_init_block_rsv(&fs_info->global_block_rsv,

fs/btrfs/disk-io.c

2827

btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);

fs/btrfs/disk-io.c

2828

btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);

fs/btrfs/disk-io.c

2829

btrfs_init_block_rsv(&fs_info->remap_block_rsv, BTRFS_BLOCK_RSV_REMAP);

fs/btrfs/disk-io.c

2830

btrfs_init_block_rsv(&fs_info->treelog_rsv, BTRFS_BLOCK_RSV_TREELOG);

fs/btrfs/disk-io.c

2831

btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);

fs/btrfs/disk-io.c

2832

btrfs_init_block_rsv(&fs_info->delayed_block_rsv,

fs/btrfs/disk-io.c

2834

btrfs_init_block_rsv(&fs_info->delayed_refs_rsv,

fs/btrfs/disk-io.c

2837

atomic_set(&fs_info->async_delalloc_pages, 0);

fs/btrfs/disk-io.c

2838

atomic_set(&fs_info->defrag_running, 0);

fs/btrfs/disk-io.c

2839

atomic_set(&fs_info->nr_delayed_iputs, 0);

fs/btrfs/disk-io.c

2840

atomic64_set(&fs_info->tree_mod_seq, 0);

fs/btrfs/disk-io.c

2841

fs_info->global_root_tree = RB_ROOT;

fs/btrfs/disk-io.c

2842

fs_info->max_inline = BTRFS_DEFAULT_MAX_INLINE;

fs/btrfs/disk-io.c

2843

fs_info->metadata_ratio = 0;

fs/btrfs/disk-io.c

2844

fs_info->defrag_inodes = RB_ROOT;

fs/btrfs/disk-io.c

2845

atomic64_set(&fs_info->free_chunk_space, 0);

fs/btrfs/disk-io.c

2846

fs_info->tree_mod_log = RB_ROOT;

fs/btrfs/disk-io.c

2847

fs_info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;

fs/btrfs/disk-io.c

2848

btrfs_init_ref_verify(fs_info);

fs/btrfs/disk-io.c

285

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

fs/btrfs/disk-io.c

2850

fs_info->thread_pool_size = min_t(unsigned long,

fs/btrfs/disk-io.c

2853

INIT_LIST_HEAD(&fs_info->ordered_roots);

fs/btrfs/disk-io.c

2854

spin_lock_init(&fs_info->ordered_root_lock);

fs/btrfs/disk-io.c

2856

btrfs_init_scrub(fs_info);

fs/btrfs/disk-io.c

2857

btrfs_init_balance(fs_info);

fs/btrfs/disk-io.c

2858

btrfs_init_async_reclaim_work(fs_info);

fs/btrfs/disk-io.c

2859

btrfs_init_extent_map_shrinker_work(fs_info);

fs/btrfs/disk-io.c

2861

rwlock_init(&fs_info->block_group_cache_lock);

fs/btrfs/disk-io.c

2862

fs_info->block_group_cache_tree = RB_ROOT_CACHED;

fs/btrfs/disk-io.c

2864

btrfs_extent_io_tree_init(fs_info, &fs_info->excluded_extents,

fs/btrfs/disk-io.c

2867

mutex_init(&fs_info->ordered_operations_mutex);

fs/btrfs/disk-io.c

2868

mutex_init(&fs_info->tree_log_mutex);

fs/btrfs/disk-io.c

2869

mutex_init(&fs_info->chunk_mutex);

fs/btrfs/disk-io.c

2870

mutex_init(&fs_info->transaction_kthread_mutex);

fs/btrfs/disk-io.c

2871

mutex_init(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

2872

mutex_init(&fs_info->remap_mutex);

fs/btrfs/disk-io.c

2873

mutex_init(&fs_info->ro_block_group_mutex);

fs/btrfs/disk-io.c

2874

init_rwsem(&fs_info->commit_root_sem);

fs/btrfs/disk-io.c

2875

init_rwsem(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

2876

init_rwsem(&fs_info->subvol_sem);

fs/btrfs/disk-io.c

2877

sema_init(&fs_info->uuid_tree_rescan_sem, 1);

fs/btrfs/disk-io.c

2879

btrfs_init_dev_replace_locks(fs_info);

fs/btrfs/disk-io.c

2880

btrfs_init_qgroup(fs_info);

fs/btrfs/disk-io.c

2881

btrfs_discard_init(fs_info);

fs/btrfs/disk-io.c

2883

btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);

fs/btrfs/disk-io.c

2884

btrfs_init_free_cluster(&fs_info->data_alloc_cluster);

fs/btrfs/disk-io.c

2886

init_waitqueue_head(&fs_info->transaction_throttle);

fs/btrfs/disk-io.c

2887

init_waitqueue_head(&fs_info->transaction_wait);

fs/btrfs/disk-io.c

2888

init_waitqueue_head(&fs_info->transaction_blocked_wait);

fs/btrfs/disk-io.c

2889

init_waitqueue_head(&fs_info->async_submit_wait);

fs/btrfs/disk-io.c

2890

init_waitqueue_head(&fs_info->delayed_iputs_wait);

fs/btrfs/disk-io.c

2893

fs_info->nodesize = 4096;

fs/btrfs/disk-io.c

2894

fs_info->sectorsize = 4096;

fs/btrfs/disk-io.c

2895

fs_info->sectorsize_bits = ilog2(4096);

fs/btrfs/disk-io.c

2896

fs_info->stripesize = 4096;

fs/btrfs/disk-io.c

2899

fs_info->compress_type = BTRFS_COMPRESS_ZLIB;

fs/btrfs/disk-io.c

2901

fs_info->max_extent_size = BTRFS_MAX_EXTENT_SIZE;

fs/btrfs/disk-io.c

2903

spin_lock_init(&fs_info->swapfile_pins_lock);

fs/btrfs/disk-io.c

2904

fs_info->swapfile_pins = RB_ROOT;

fs/btrfs/disk-io.c

2906

fs_info->bg_reclaim_threshold = BTRFS_DEFAULT_RECLAIM_THRESH;

fs/btrfs/disk-io.c

2907

INIT_WORK(&fs_info->reclaim_bgs_work, btrfs_reclaim_bgs_work);

fs/btrfs/disk-io.c

2910

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

fs/btrfs/disk-io.c

2914

fs_info->sb = sb;

fs/btrfs/disk-io.c

2919

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

fs/btrfs/disk-io.c

2923

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

fs/btrfs/disk-io.c

2927

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

fs/btrfs/disk-io.c

2931

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

fs/btrfs/disk-io.c

2935

fs_info->dirty_metadata_batch = PAGE_SIZE *

fs/btrfs/disk-io.c

2938

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

fs/btrfs/disk-io.c

2942

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

fs/btrfs/disk-io.c

2947

btrfs_init_delayed_root(&fs_info->delayed_root);

fs/btrfs/disk-io.c

2950

set_bit(BTRFS_FS_STATE_RO, &fs_info->fs_state);

fs/btrfs/disk-io.c

2951

if (btrfs_test_opt(fs_info, IGNOREMETACSUMS))

fs/btrfs/disk-io.c

2952

set_bit(BTRFS_FS_STATE_SKIP_META_CSUMS, &fs_info->fs_state);

fs/btrfs/disk-io.c

2954

return btrfs_alloc_stripe_hash_table(fs_info);

fs/btrfs/disk-io.c

2959

struct btrfs_fs_info *fs_info = data;

fs/btrfs/disk-io.c

2967

ret = btrfs_uuid_tree_iterate(fs_info);

fs/btrfs/disk-io.c

2970

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

fs/btrfs/disk-io.c

2972

up(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/disk-io.c

2978

static int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

2982

down(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/disk-io.c

2983

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

fs/btrfs/disk-io.c

2986

up(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/disk-io.c

2993

static int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

3002

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

3003

found = radix_tree_gang_lookup(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

3007

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

302

last_trans = btrfs_get_last_trans_committed(fs_info);

fs/btrfs/disk-io.c

3021

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

3048

int btrfs_start_pre_rw_mount(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

305

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3051

const bool cache_opt = btrfs_test_opt(fs_info, SPACE_CACHE);

fs/btrfs/disk-io.c

3054

if (btrfs_test_opt(fs_info, CLEAR_CACHE) &&

fs/btrfs/disk-io.c

3055

btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {

fs/btrfs/disk-io.c

3056

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))

fs/btrfs/disk-io.c

3057

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3059

else if (btrfs_fs_incompat(fs_info, REMAP_TREE))

fs/btrfs/disk-io.c

3060

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

fs/btrfs/disk-io.c

3063

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

fs/btrfs/disk-io.c

3064

!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID)) {

fs/btrfs/disk-io.c

3065

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

fs/btrfs/disk-io.c

3070

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

fs/btrfs/disk-io.c

3071

ret = btrfs_rebuild_free_space_tree(fs_info);

fs/btrfs/disk-io.c

3073

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3079

if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&

fs/btrfs/disk-io.c

3080

!btrfs_test_opt(fs_info, FREE_SPACE_TREE)) {

fs/btrfs/disk-io.c

3081

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

fs/btrfs/disk-io.c

3082

ret = btrfs_delete_free_space_tree(fs_info);

fs/btrfs/disk-io.c

3084

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3094

ret = btrfs_delete_orphan_free_space_entries(fs_info);

fs/btrfs/disk-io.c

3096

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

fs/btrfs/disk-io.c

310

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

fs/btrfs/disk-io.c

3110

ret = btrfs_find_orphan_roots(fs_info);

fs/btrfs/disk-io.c

3114

ret = btrfs_cleanup_fs_roots(fs_info);

fs/btrfs/disk-io.c

3118

down_read(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

3119

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

fs/btrfs/disk-io.c

3120

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

fs/btrfs/disk-io.c

3121

up_read(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

3124

up_read(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

3126

mutex_lock(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

3127

ret = btrfs_recover_relocation(fs_info);

fs/btrfs/disk-io.c

3128

mutex_unlock(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

3130

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

fs/btrfs/disk-io.c

3134

if (btrfs_test_opt(fs_info, FREE_SPACE_TREE) &&

fs/btrfs/disk-io.c

3135

!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {

fs/btrfs/disk-io.c

3136

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

fs/btrfs/disk-io.c

3137

ret = btrfs_create_free_space_tree(fs_info);

fs/btrfs/disk-io.c

3139

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3145

if (cache_opt != btrfs_free_space_cache_v1_active(fs_info)) {

fs/btrfs/disk-io.c

3146

ret = btrfs_set_free_space_cache_v1_active(fs_info, cache_opt);

fs/btrfs/disk-io.c

315

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

fs/btrfs/disk-io.c

3151

ret = btrfs_resume_balance_async(fs_info);

fs/btrfs/disk-io.c

3155

ret = btrfs_resume_dev_replace_async(fs_info);

fs/btrfs/disk-io.c

3157

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

fs/btrfs/disk-io.c

3161

btrfs_qgroup_rescan_resume(fs_info);

fs/btrfs/disk-io.c

3163

if (!fs_info->uuid_root) {

fs/btrfs/disk-io.c

3164

btrfs_info(fs_info, "creating UUID tree");

fs/btrfs/disk-io.c

3165

ret = btrfs_create_uuid_tree(fs_info);

fs/btrfs/disk-io.c

3167

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3191

int btrfs_check_features(struct btrfs_fs_info *fs_info, bool is_rw_mount)

fs/btrfs/disk-io.c

3193

struct btrfs_super_block *disk_super = fs_info->super_copy;

fs/btrfs/disk-io.c

3199

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3207

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

fs/btrfs/disk-io.c

3208

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3210

fs_info->nodesize, fs_info->sectorsize);

fs/btrfs/disk-io.c

3218

if (fs_info->compress_type == BTRFS_COMPRESS_LZO)

fs/btrfs/disk-io.c

3220

else if (fs_info->compress_type == BTRFS_COMPRESS_ZSTD)

fs/btrfs/disk-io.c

3231

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3243

!btrfs_test_opt(fs_info, NOLOGREPLAY)) {

fs/btrfs/disk-io.c

3244

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3254

if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE) &&

fs/btrfs/disk-io.c

3255

(!btrfs_fs_incompat(fs_info, NO_HOLES) ||

fs/btrfs/disk-io.c

3256

!btrfs_test_opt(fs_info, FREE_SPACE_TREE))) {

fs/btrfs/disk-io.c

3257

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3269

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

fs/btrfs/disk-io.c

3270

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3272

PAGE_SIZE, fs_info->sectorsize);

fs/btrfs/disk-io.c

3277

spin_lock(&fs_info->super_lock);

fs/btrfs/disk-io.c

3279

spin_unlock(&fs_info->super_lock);

fs/btrfs/disk-io.c

3284

static bool fs_is_full_ro(const struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

3286

if (!sb_rdonly(fs_info->sb))

fs/btrfs/disk-io.c

3288

if (unlikely(fs_info->mount_opt & BTRFS_MOUNT_FULL_RO_MASK))

fs/btrfs/disk-io.c

330

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/disk-io.c

3301

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/disk-io.c

3308

ret = init_mount_fs_info(fs_info, sb);

fs/btrfs/disk-io.c

331

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

fs/btrfs/disk-io.c

3313

tree_root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID,

fs/btrfs/disk-io.c

3315

fs_info->tree_root = tree_root;

fs/btrfs/disk-io.c

3316

chunk_root = btrfs_alloc_root(fs_info, BTRFS_CHUNK_TREE_OBJECTID,

fs/btrfs/disk-io.c

3318

fs_info->chunk_root = chunk_root;

fs/btrfs/disk-io.c

3339

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

fs/btrfs/disk-io.c

3346

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

fs/btrfs/disk-io.c

3353

fs_info->csum_size = btrfs_super_csum_size(disk_super);

fs/btrfs/disk-io.c

3354

fs_info->csum_type = csum_type;

fs/btrfs/disk-io.c

3356

btrfs_init_csum_hash(fs_info, csum_type);

fs/btrfs/disk-io.c

3362

if (btrfs_check_super_csum(fs_info, disk_super)) {

fs/btrfs/disk-io.c

3363

btrfs_err(fs_info, "superblock checksum mismatch");

fs/btrfs/disk-io.c

3374

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

fs/btrfs/disk-io.c

3377

disk_super = fs_info->super_copy;

fs/btrfs/disk-io.c

3379

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

fs/btrfs/disk-io.c

3380

sizeof(*fs_info->super_for_commit));

fs/btrfs/disk-io.c

3382

ret = btrfs_validate_mount_super(fs_info);

fs/btrfs/disk-io.c

3384

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

fs/btrfs/disk-io.c

3390

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

fs/btrfs/disk-io.c

3397

WRITE_ONCE(fs_info->fs_error, -EUCLEAN);

fs/btrfs/disk-io.c

3400

if (fs_is_full_ro(fs_info))

fs/btrfs/disk-io.c

3401

WRITE_ONCE(fs_info->fs_error, -EROFS);

fs/btrfs/disk-io.c

3407

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

fs/btrfs/disk-io.c

3408

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

fs/btrfs/disk-io.c

3410

fs_info->nodesize = nodesize;

fs/btrfs/disk-io.c

3411

fs_info->nodesize_bits = ilog2(nodesize);

fs/btrfs/disk-io.c

3412

fs_info->sectorsize = sectorsize;

fs/btrfs/disk-io.c

3413

fs_info->sectorsize_bits = ilog2(sectorsize);

fs/btrfs/disk-io.c

3414

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

fs/btrfs/disk-io.c

3415

fs_info->block_max_order = ilog2((BITS_PER_LONG << fs_info->sectorsize_bits) >> PAGE_SHIFT);

fs/btrfs/disk-io.c

3416

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

fs/btrfs/disk-io.c

3417

fs_info->stripesize = stripesize;

fs/btrfs/disk-io.c

3418

fs_info->fs_devices->fs_info = fs_info;

fs/btrfs/disk-io.c

3420

if (fs_info->sectorsize > PAGE_SIZE)

fs/btrfs/disk-io.c

3421

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3423

fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/disk-io.c

3428

btrfs_set_free_space_cache_settings(fs_info);

fs/btrfs/disk-io.c

343

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

fs/btrfs/disk-io.c

3430

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

fs/btrfs/disk-io.c

3435

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

fs/btrfs/disk-io.c

3440

remap_root = btrfs_alloc_root(fs_info, BTRFS_REMAP_TREE_OBJECTID,

fs/btrfs/disk-io.c

3442

fs_info->remap_root = remap_root;

fs/btrfs/disk-io.c

3453

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

fs/btrfs/disk-io.c

3455

ret = btrfs_alloc_compress_wsm(fs_info);

fs/btrfs/disk-io.c

3458

ret = btrfs_init_workqueues(fs_info);

fs/btrfs/disk-io.c

3468

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

fs/btrfs/disk-io.c

3470

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/disk-io.c

3471

ret = btrfs_read_sys_array(fs_info);

fs/btrfs/disk-io.c

3472

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/disk-io.c

3474

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

fs/btrfs/disk-io.c

3483

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

fs/btrfs/disk-io.c

3487

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

fs/btrfs/disk-io.c

3491

ret = btrfs_read_chunk_tree(fs_info);

fs/btrfs/disk-io.c

3493

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

fs/btrfs/disk-io.c

3506

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

fs/btrfs/disk-io.c

3511

ret = init_tree_roots(fs_info);

fs/btrfs/disk-io.c

3520

ret = btrfs_get_dev_zone_info_all_devices(fs_info);

fs/btrfs/disk-io.c

3522

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3535

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

fs/btrfs/disk-io.c

3536

fs_info->generation == btrfs_super_uuid_tree_generation(disk_super))

fs/btrfs/disk-io.c

3537

set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);

fs/btrfs/disk-io.c

3539

if (unlikely(btrfs_verify_dev_items(fs_info))) {

fs/btrfs/disk-io.c

3543

ret = btrfs_verify_dev_extents(fs_info);

fs/btrfs/disk-io.c

3545

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3550

ret = btrfs_recover_balance(fs_info);

fs/btrfs/disk-io.c

3552

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

fs/btrfs/disk-io.c

3556

ret = btrfs_init_dev_stats(fs_info);

fs/btrfs/disk-io.c

3558

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

fs/btrfs/disk-io.c

3562

ret = btrfs_init_dev_replace(fs_info);

fs/btrfs/disk-io.c

3564

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

fs/btrfs/disk-io.c

3568

ret = btrfs_check_zoned_mode(fs_info);

fs/btrfs/disk-io.c

357

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/disk-io.c

3570

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

fs/btrfs/disk-io.c

3577

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

fs/btrfs/disk-io.c

3582

ret = btrfs_sysfs_add_mounted(fs_info);

fs/btrfs/disk-io.c

3584

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

fs/btrfs/disk-io.c

3588

ret = btrfs_init_space_info(fs_info);

fs/btrfs/disk-io.c

359

const u32 csum_size = fs_info->csum_size;

fs/btrfs/disk-io.c

3590

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

fs/btrfs/disk-io.c

3594

ret = btrfs_read_block_groups(fs_info);

fs/btrfs/disk-io.c

3596

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

fs/btrfs/disk-io.c

3600

if (btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/disk-io.c

3601

ret = btrfs_populate_fully_remapped_bgs_list(fs_info);

fs/btrfs/disk-io.c

3603

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

fs/btrfs/disk-io.c

3608

btrfs_free_zone_cache(fs_info);

fs/btrfs/disk-io.c

3610

btrfs_check_active_zone_reservation(fs_info);

fs/btrfs/disk-io.c

3612

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

fs/btrfs/disk-io.c

3613

!btrfs_check_rw_degradable(fs_info, NULL)) {

fs/btrfs/disk-io.c

3614

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

3620

fs_info->cleaner_kthread = kthread_run(cleaner_kthread, fs_info,

fs/btrfs/disk-io.c

3622

if (IS_ERR(fs_info->cleaner_kthread)) {

fs/btrfs/disk-io.c

3623

ret = PTR_ERR(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

3627

fs_info->transaction_kthread = kthread_run(transaction_kthread,

fs/btrfs/disk-io.c

3630

if (IS_ERR(fs_info->transaction_kthread)) {

fs/btrfs/disk-io.c

3631

ret = PTR_ERR(fs_info->transaction_kthread);

fs/btrfs/disk-io.c

3639

btrfs_zoned_reserve_data_reloc_bg(fs_info);

fs/btrfs/disk-io.c

364

const bool ignore_csum = btrfs_test_opt(fs_info, IGNOREMETACSUMS);

fs/btrfs/disk-io.c

3641

ret = btrfs_read_qgroup_config(fs_info);

fs/btrfs/disk-io.c

3645

if (btrfs_build_ref_tree(fs_info))

fs/btrfs/disk-io.c

3646

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

fs/btrfs/disk-io.c

3650

!btrfs_test_opt(fs_info, NOLOGREPLAY)) {

fs/btrfs/disk-io.c

3651

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

fs/btrfs/disk-io.c

3652

ret = btrfs_replay_log(fs_info, fs_devices);

fs/btrfs/disk-io.c

3657

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

fs/btrfs/disk-io.c

3658

if (IS_ERR(fs_info->fs_root)) {

fs/btrfs/disk-io.c

3659

ret = PTR_ERR(fs_info->fs_root);

fs/btrfs/disk-io.c

3660

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

fs/btrfs/disk-io.c

3661

fs_info->fs_root = NULL;

fs/btrfs/disk-io.c

3668

ret = btrfs_start_pre_rw_mount(fs_info);

fs/btrfs/disk-io.c

3670

close_ctree(fs_info);

fs/btrfs/disk-io.c

3673

btrfs_discard_resume(fs_info);

fs/btrfs/disk-io.c

3675

if (fs_info->uuid_root &&

fs/btrfs/disk-io.c

3676

(btrfs_test_opt(fs_info, RESCAN_UUID_TREE) ||

fs/btrfs/disk-io.c

3677

fs_info->generation != btrfs_super_uuid_tree_generation(disk_super))) {

fs/btrfs/disk-io.c

3678

btrfs_info(fs_info, "checking UUID tree");

fs/btrfs/disk-io.c

3679

ret = btrfs_check_uuid_tree(fs_info);

fs/btrfs/disk-io.c

3681

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

fs/btrfs/disk-io.c

3682

close_ctree(fs_info);

fs/btrfs/disk-io.c

3687

set_bit(BTRFS_FS_OPEN, &fs_info->flags);

fs/btrfs/disk-io.c

3690

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

fs/btrfs/disk-io.c

3691

wake_up_process(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

3696

btrfs_free_qgroup_config(fs_info);

fs/btrfs/disk-io.c

3698

kthread_stop(fs_info->transaction_kthread);

fs/btrfs/disk-io.c

3699

btrfs_cleanup_transaction(fs_info);

fs/btrfs/disk-io.c

370

btrfs_err_rl(fs_info,

fs/btrfs/disk-io.c

3700

btrfs_free_fs_roots(fs_info);

fs/btrfs/disk-io.c

3702

kthread_stop(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

3708

filemap_write_and_wait(fs_info->btree_inode->i_mapping);

fs/btrfs/disk-io.c

3711

btrfs_sysfs_remove_mounted(fs_info);

fs/btrfs/disk-io.c

3714

btrfs_sysfs_remove_fsid(fs_info->fs_devices);

fs/btrfs/disk-io.c

3717

btrfs_put_block_group_cache(fs_info);

fs/btrfs/disk-io.c

3720

if (fs_info->data_reloc_root)

fs/btrfs/disk-io.c

3721

btrfs_drop_and_free_fs_root(fs_info, fs_info->data_reloc_root);

fs/btrfs/disk-io.c

3722

free_root_pointers(fs_info, true);

fs/btrfs/disk-io.c

3723

invalidate_inode_pages2(fs_info->btree_inode->i_mapping);

fs/btrfs/disk-io.c

3726

btrfs_stop_all_workers(fs_info);

fs/btrfs/disk-io.c

3727

btrfs_free_block_groups(fs_info);

fs/btrfs/disk-io.c

3729

btrfs_mapping_tree_free(fs_info);

fs/btrfs/disk-io.c

3731

iput(fs_info->btree_inode);

fs/btrfs/disk-io.c

3745

btrfs_warn_rl(device->fs_info,

fs/btrfs/disk-io.c

376

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

fs/btrfs/disk-io.c

3778

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/disk-io.c

3800

btrfs_err(device->fs_info,

fs/btrfs/disk-io.c

3812

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

fs/btrfs/disk-io.c

3819

btrfs_err(device->fs_info,

fs/btrfs/disk-io.c

382

btrfs_err(fs_info,

fs/btrfs/disk-io.c

3848

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

fs/btrfs/disk-io.c

3907

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

fs/btrfs/disk-io.c

393

btrfs_warn_rl(fs_info,

fs/btrfs/disk-io.c

4046

int write_all_supers(struct btrfs_fs_info *fs_info, int max_mirrors)

fs/btrfs/disk-io.c

405

btrfs_err(fs_info,

fs/btrfs/disk-io.c

4058

do_barriers = !btrfs_test_opt(fs_info, NOBARRIER);

fs/btrfs/disk-io.c

4066

ret = backup_super_roots(fs_info);

fs/btrfs/disk-io.c

4071

sb = fs_info->super_for_commit;

fs/btrfs/disk-io.c

4074

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

fs/btrfs/disk-io.c

4075

head = &fs_info->fs_devices->devices;

fs/btrfs/disk-io.c

4076

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

fs/btrfs/disk-io.c

4079

ret = barrier_all_devices(fs_info);

fs/btrfs/disk-io.c

4082

&fs_info->fs_devices->device_list_mutex);

fs/btrfs/disk-io.c

4083

btrfs_handle_fs_error(fs_info, ret,

fs/btrfs/disk-io.c

4115

ret = btrfs_validate_write_super(fs_info, sb);

fs/btrfs/disk-io.c

4117

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

fs/btrfs/disk-io.c

4118

btrfs_handle_fs_error(fs_info, -EUCLEAN,

fs/btrfs/disk-io.c

412

btrfs_err_rl(eb->fs_info,

fs/btrfs/disk-io.c

4128

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

fs/btrfs/disk-io.c

4130

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

fs/btrfs/disk-io.c

4133

btrfs_handle_fs_error(fs_info, -EIO,

fs/btrfs/disk-io.c

4151

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

fs/btrfs/disk-io.c

4153

btrfs_handle_fs_error(fs_info, -EIO,

fs/btrfs/disk-io.c

4162

void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

4167

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4168

radix_tree_delete(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

4172

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4174

if (BTRFS_FS_ERROR(fs_info)) {

fs/btrfs/disk-io.c

4186

int btrfs_commit_super(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4188

mutex_lock(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

4189

btrfs_run_delayed_iputs(fs_info);

fs/btrfs/disk-io.c

4190

mutex_unlock(&fs_info->cleaner_mutex);

fs/btrfs/disk-io.c

4191

wake_up_process(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

4194

down_write(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

4195

up_write(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

4197

return btrfs_commit_current_transaction(fs_info->tree_root);

fs/btrfs/disk-io.c

4200

static void warn_about_uncommitted_trans(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4210

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

fs/btrfs/disk-io.c

4211

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

fs/btrfs/disk-io.c

4225

btrfs_warn(fs_info,

fs/btrfs/disk-io.c

4230

if (trans == fs_info->running_transaction)

fs/btrfs/disk-io.c

4231

fs_info->running_transaction = NULL;

fs/btrfs/disk-io.c

4235

trace_btrfs_transaction_commit(fs_info);

fs/btrfs/disk-io.c

4240

void __cold close_ctree(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4244

set_bit(BTRFS_FS_CLOSING_START, &fs_info->flags);

fs/btrfs/disk-io.c

4255

btrfs_wake_unfinished_drop(fs_info);

fs/btrfs/disk-io.c

4266

cancel_work_sync(&fs_info->reclaim_bgs_work);

fs/btrfs/disk-io.c

427

btrfs_err(fs_info,

fs/btrfs/disk-io.c

4273

kthread_park(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

4276

btrfs_qgroup_wait_for_completion(fs_info, false);

fs/btrfs/disk-io.c

4279

down(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/disk-io.c

4281

up(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/disk-io.c

4284

btrfs_pause_balance(fs_info);

fs/btrfs/disk-io.c

4286

btrfs_dev_replace_suspend_for_unmount(fs_info);

fs/btrfs/disk-io.c

4288

btrfs_scrub_cancel(fs_info);

fs/btrfs/disk-io.c

4291

wait_event(fs_info->transaction_wait,

fs/btrfs/disk-io.c

4292

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

fs/btrfs/disk-io.c

4295

btrfs_cleanup_defrag_inodes(fs_info);

fs/btrfs/disk-io.c

4302

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/disk-io.c

4303

btrfs_error_commit_super(fs_info);

fs/btrfs/disk-io.c

4314

btrfs_flush_workqueue(fs_info->fixup_workers);

fs/btrfs/disk-io.c

4323

btrfs_flush_workqueue(fs_info->delalloc_workers);

fs/btrfs/disk-io.c

4336

btrfs_flush_workqueue(fs_info->workers);

fs/btrfs/disk-io.c

4348

flush_workqueue(fs_info->endio_workers);

fs/btrfs/disk-io.c

4370

btrfs_flush_workqueue(fs_info->endio_write_workers);

fs/btrfs/disk-io.c

4372

btrfs_flush_workqueue(fs_info->endio_freespace_worker);

fs/btrfs/disk-io.c

4377

btrfs_run_delayed_iputs(fs_info);

fs/btrfs/disk-io.c

4379

cancel_work_sync(&fs_info->async_reclaim_work);

fs/btrfs/disk-io.c

4380

cancel_work_sync(&fs_info->async_data_reclaim_work);

fs/btrfs/disk-io.c

4381

cancel_work_sync(&fs_info->preempt_reclaim_work);

fs/btrfs/disk-io.c

4382

cancel_work_sync(&fs_info->em_shrinker_work);

fs/btrfs/disk-io.c

4391

btrfs_run_delayed_iputs(fs_info);

fs/btrfs/disk-io.c

4394

set_bit(BTRFS_FS_STATE_NO_DELAYED_IPUT, &fs_info->fs_state);

fs/btrfs/disk-io.c

4397

btrfs_discard_cleanup(fs_info);

fs/btrfs/disk-io.c

4399

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

fs/btrfs/disk-io.c

4404

btrfs_delete_unused_bgs(fs_info);

fs/btrfs/disk-io.c

4417

btrfs_flush_workqueue(fs_info->delayed_workers);

fs/btrfs/disk-io.c

4425

if (!btrfs_is_shutdown(fs_info)) {

fs/btrfs/disk-io.c

4426

ret = btrfs_commit_super(fs_info);

fs/btrfs/disk-io.c

4428

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

fs/btrfs/disk-io.c

4432

kthread_stop(fs_info->transaction_kthread);

fs/btrfs/disk-io.c

4433

kthread_stop(fs_info->cleaner_kthread);

fs/btrfs/disk-io.c

4435

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

fs/btrfs/disk-io.c

4436

set_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags);

fs/btrfs/disk-io.c

4438

if (btrfs_check_quota_leak(fs_info)) {

fs/btrfs/disk-io.c

4440

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

fs/btrfs/disk-io.c

4443

btrfs_free_qgroup_config(fs_info);

fs/btrfs/disk-io.c

4444

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

fs/btrfs/disk-io.c

4446

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

fs/btrfs/disk-io.c

4447

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

fs/btrfs/disk-io.c

4448

percpu_counter_sum(&fs_info->delalloc_bytes));

fs/btrfs/disk-io.c

4451

if (percpu_counter_sum(&fs_info->ordered_bytes))

fs/btrfs/disk-io.c

4452

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

fs/btrfs/disk-io.c

4453

percpu_counter_sum(&fs_info->ordered_bytes));

fs/btrfs/disk-io.c

4455

btrfs_sysfs_remove_mounted(fs_info);

fs/btrfs/disk-io.c

4456

btrfs_sysfs_remove_fsid(fs_info->fs_devices);

fs/btrfs/disk-io.c

4458

btrfs_put_block_group_cache(fs_info);

fs/btrfs/disk-io.c

4464

invalidate_inode_pages2(fs_info->btree_inode->i_mapping);

fs/btrfs/disk-io.c

4465

btrfs_stop_all_workers(fs_info);

fs/btrfs/disk-io.c

4468

warn_about_uncommitted_trans(fs_info);

fs/btrfs/disk-io.c

4470

clear_bit(BTRFS_FS_OPEN, &fs_info->flags);

fs/btrfs/disk-io.c

4471

free_root_pointers(fs_info, true);

fs/btrfs/disk-io.c

4472

btrfs_free_fs_roots(fs_info);

fs/btrfs/disk-io.c

4481

btrfs_free_block_groups(fs_info);

fs/btrfs/disk-io.c

4483

iput(fs_info->btree_inode);

fs/btrfs/disk-io.c

4485

btrfs_mapping_tree_free(fs_info);

fs/btrfs/disk-io.c

4491

struct btrfs_fs_info *fs_info = buf->fs_info;

fs/btrfs/disk-io.c

4504

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

fs/btrfs/disk-io.c

4506

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

fs/btrfs/disk-io.c

4508

btrfs_crit(fs_info,

fs/btrfs/disk-io.c

451

btrfs_err(fs_info,

fs/btrfs/disk-io.c

4510

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

fs/btrfs/disk-io.c

4515

static void __btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

4528

btrfs_balance_delayed_items(fs_info);

fs/btrfs/disk-io.c

4530

ret = __percpu_counter_compare(&fs_info->dirty_metadata_bytes,

fs/btrfs/disk-io.c

4532

fs_info->dirty_metadata_batch);

fs/btrfs/disk-io.c

4534

balance_dirty_pages_ratelimited(fs_info->btree_inode->i_mapping);

fs/btrfs/disk-io.c

4538

void btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4540

__btrfs_btree_balance_dirty(fs_info, 1);

fs/btrfs/disk-io.c

4543

void btrfs_btree_balance_dirty_nodelay(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4545

__btrfs_btree_balance_dirty(fs_info, 0);

fs/btrfs/disk-io.c

4548

static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4551

btrfs_cleanup_transaction(fs_info);

fs/btrfs/disk-io.c

4553

down_write(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

4554

up_write(&fs_info->cleanup_work_sem);

fs/btrfs/disk-io.c

4557

static void btrfs_drop_all_logs(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4563

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4564

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

fs/btrfs/disk-io.c

4571

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4581

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4583

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4584

btrfs_free_log_root_tree(NULL, fs_info);

fs/btrfs/disk-io.c

4602

static void btrfs_destroy_all_ordered_extents(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4607

spin_lock(&fs_info->ordered_root_lock);

fs/btrfs/disk-io.c

4608

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

fs/btrfs/disk-io.c

4613

&fs_info->ordered_roots);

fs/btrfs/disk-io.c

4615

spin_unlock(&fs_info->ordered_root_lock);

fs/btrfs/disk-io.c

4619

spin_lock(&fs_info->ordered_root_lock);

fs/btrfs/disk-io.c

4621

spin_unlock(&fs_info->ordered_root_lock);

fs/btrfs/disk-io.c

4629

btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);

fs/btrfs/disk-io.c

4665

static void btrfs_destroy_all_delalloc_inodes(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4670

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/disk-io.c

4671

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

fs/btrfs/disk-io.c

4677

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/disk-io.c

4682

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/disk-io.c

4684

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/disk-io.c

4687

static void btrfs_destroy_marked_extents(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

4699

eb = find_extent_buffer(fs_info, start);

fs/btrfs/disk-io.c

4700

start += fs_info->nodesize;

fs/btrfs/disk-io.c

4714

static void btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

4729

mutex_lock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/disk-io.c

4732

mutex_unlock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/disk-io.c

4738

btrfs_error_unpin_extent_range(fs_info, start, end);

fs/btrfs/disk-io.c

4739

mutex_unlock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/disk-io.c

4765

struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4789

btrfs_dec_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/disk-io.c

4811

static void btrfs_free_all_qgroup_pertrans(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4817

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4819

ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

4829

radix_tree_tag_clear(&fs_info->fs_roots_radix,

fs/btrfs/disk-io.c

4834

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

4839

struct btrfs_fs_info *fs_info = cur_trans->fs_info;

fs/btrfs/disk-io.c

4842

btrfs_cleanup_dirty_bgs(cur_trans, fs_info);

fs/btrfs/disk-io.c

4854

wake_up(&fs_info->transaction_blocked_wait);

fs/btrfs/disk-io.c

4857

wake_up(&fs_info->transaction_wait);

fs/btrfs/disk-io.c

4859

btrfs_destroy_marked_extents(fs_info, &cur_trans->dirty_pages,

fs/btrfs/disk-io.c

4861

btrfs_destroy_pinned_extent(fs_info, &cur_trans->pinned_extents);

fs/btrfs/disk-io.c

4867

static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

4871

mutex_lock(&fs_info->transaction_kthread_mutex);

fs/btrfs/disk-io.c

4873

spin_lock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4874

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

fs/btrfs/disk-io.c

4875

t = list_first_entry(&fs_info->trans_list,

fs/btrfs/disk-io.c

4879

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4880

btrfs_wait_for_commit(fs_info, t->transid);

fs/btrfs/disk-io.c

4882

spin_lock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4885

if (t == fs_info->running_transaction) {

fs/btrfs/disk-io.c

4887

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4895

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4899

spin_lock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4900

if (t == fs_info->running_transaction)

fs/btrfs/disk-io.c

4901

fs_info->running_transaction = NULL;

fs/btrfs/disk-io.c

4903

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4906

trace_btrfs_transaction_commit(fs_info);

fs/btrfs/disk-io.c

4907

spin_lock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4909

spin_unlock(&fs_info->trans_lock);

fs/btrfs/disk-io.c

4910

btrfs_destroy_all_ordered_extents(fs_info);

fs/btrfs/disk-io.c

4911

btrfs_destroy_delayed_inodes(fs_info);

fs/btrfs/disk-io.c

4912

btrfs_assert_delayed_root_empty(fs_info);

fs/btrfs/disk-io.c

4913

btrfs_destroy_all_delalloc_inodes(fs_info);

fs/btrfs/disk-io.c

4914

btrfs_drop_all_logs(fs_info);

fs/btrfs/disk-io.c

4915

btrfs_free_all_qgroup_pertrans(fs_info);

fs/btrfs/disk-io.c

4916

mutex_unlock(&fs_info->transaction_kthread_mutex);

fs/btrfs/disk-io.c

4966

btrfs_warn(root->fs_info,

fs/btrfs/disk-io.c

508

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

fs/btrfs/disk-io.c

509

struct btrfs_subpage_info *spi = fs_info->subpage_info;

fs/btrfs/disk-io.c

515

if (fs_info->sectorsize == PAGE_SIZE) {

fs/btrfs/disk-io.c

539

cur = page_start + cur_bit * fs_info->sectorsize;

fs/btrfs/disk-io.c

541

eb = find_extent_buffer(fs_info, cur);

fs/btrfs/disk-io.c

548

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

fs/btrfs/disk-io.c

565

struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

569

if (btrfs_is_testing(fs_info))

fs/btrfs/disk-io.c

570

return alloc_test_extent_buffer(fs_info, bytenr);

fs/btrfs/disk-io.c

571

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

fs/btrfs/disk-io.c

581

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

fs/btrfs/disk-io.c

589

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

fs/btrfs/disk-io.c

603

static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

612

root->fs_info = fs_info;

fs/btrfs/disk-io.c

62

static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.c

63

static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.c

650

if (!btrfs_is_testing(fs_info)) {

fs/btrfs/disk-io.c

651

btrfs_extent_io_tree_init(fs_info, &root->dirty_log_pages,

fs/btrfs/disk-io.c

653

btrfs_extent_io_tree_init(fs_info, &root->log_csum_range,

fs/btrfs/disk-io.c

661

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

662

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

fs/btrfs/disk-io.c

663

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/disk-io.c

671

struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

675

if (!fs_info)

fs/btrfs/disk-io.c

678

root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID, GFP_KERNEL);

fs/btrfs/disk-io.c

70

struct btrfs_fs_info *fs_info = buf->fs_info;

fs/btrfs/disk-io.c

707

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/disk-io.c

711

write_lock(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

712

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

fs/btrfs/disk-io.c

713

write_unlock(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

717

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

fs/btrfs/disk-io.c

725

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/disk-io.c

727

write_lock(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

728

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

fs/btrfs/disk-io.c

729

write_unlock(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

732

struct btrfs_root *btrfs_global_root(struct btrfs_fs_info *fs_info,

fs/btrfs/disk-io.c

738

read_lock(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

739

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

fs/btrfs/disk-io.c

742

read_unlock(&fs_info->global_root_lock);

fs/btrfs/disk-io.c

747

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

fs/btrfs/disk-io.c

752

if (!btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))

fs/btrfs/disk-io.c

756

block_group = btrfs_lookup_block_group(fs_info, bytenr);

fs/btrfs/disk-io.c

758

block_group = btrfs_lookup_first_block_group(fs_info, bytenr);

fs/btrfs/disk-io.c

768

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

fs/btrfs/disk-io.c

77

btrfs_csum_init(&csum, fs_info->csum_type);

fs/btrfs/disk-io.c

773

.offset = btrfs_global_root_id(fs_info, bytenr),

fs/btrfs/disk-io.c

776

return btrfs_global_root(fs_info, &key);

fs/btrfs/disk-io.c

779

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

fs/btrfs/disk-io.c

784

.offset = btrfs_global_root_id(fs_info, bytenr),

fs/btrfs/disk-io.c

787

return btrfs_global_root(fs_info, &key);

fs/btrfs/disk-io.c

793

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/disk-io.c

795

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/disk-io.c

805

root = btrfs_alloc_root(fs_info, objectid, GFP_KERNEL);

fs/btrfs/disk-io.c

82

first_page_part = fs_info->nodesize;

fs/btrfs/disk-io.c

857

static struct btrfs_root *alloc_log_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

86

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

fs/btrfs/disk-io.c

861

root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID, GFP_NOFS);

fs/btrfs/disk-io.c

901

struct btrfs_fs_info *fs_info)

fs/btrfs/disk-io.c

905

log_root = alloc_log_tree(fs_info);

fs/btrfs/disk-io.c

909

if (!btrfs_is_zoned(fs_info)) {

fs/btrfs/disk-io.c

918

WARN_ON(fs_info->log_root_tree);

fs/btrfs/disk-io.c

919

fs_info->log_root_tree = log_root;

fs/btrfs/disk-io.c

926

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/disk-io.c

931

log_root = alloc_log_tree(fs_info);

fs/btrfs/disk-io.c

949

fs_info->nodesize);

fs/btrfs/disk-io.c

968

struct btrfs_fs_info *fs_info = tree_root->fs_info;

fs/btrfs/disk-io.c

973

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

fs/btrfs/disk-io.c

990

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

fs/btrfs/disk-io.h

118

struct btrfs_fs_info *fs_info);

fs/btrfs/disk-io.h

122

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

61

int write_all_supers(struct btrfs_fs_info *fs_info, int max_mirrors);

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

2131

btrfs_merge_delayed_refs(fs_info, delayed_refs, locked_ref);

fs/btrfs/extent-tree.c

2229

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

2237

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

fs/btrfs/extent-tree.c

2301

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

fs/btrfs/extent-tree.c

2302

cur_trans = root->fs_info->running_transaction;

fs/btrfs/extent-tree.c

2305

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

fs/btrfs/extent-tree.c

2311

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

fs/btrfs/extent-tree.c

2425

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

2426

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

fs/btrfs/extent-tree.c

2438

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

2479

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

fs/btrfs/extent-tree.c

2554

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

2566

if (btrfs_is_testing(fs_info))

fs/btrfs/extent-tree.c

2620

ref.num_bytes = fs_info->nodesize;

fs/btrfs/extent-tree.c

2649

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

2654

else if (root == fs_info->chunk_root)

fs/btrfs/extent-tree.c

2656

else if (root == fs_info->remap_root)

fs/btrfs/extent-tree.c

2661

return btrfs_get_alloc_profile(fs_info, flags);

fs/btrfs/extent-tree.c

2664

static u64 first_logical_byte(struct btrfs_fs_info *fs_info)

fs/btrfs/extent-tree.c

2669

read_lock(&fs_info->block_group_cache_lock);

fs/btrfs/extent-tree.c

2671

leftmost = rb_first_cached(&fs_info->block_group_cache_tree);

fs/btrfs/extent-tree.c

2678

read_unlock(&fs_info->block_group_cache_lock);

fs/btrfs/extent-tree.c

2708

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

fs/btrfs/extent-tree.c

2723

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

fs/btrfs/extent-tree.c

2744

static int __exclude_logged_extent(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

2750

block_group = btrfs_lookup_block_group(fs_info, start);

fs/btrfs/extent-tree.c

2766

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent-tree.c

2773

if (!btrfs_fs_incompat(fs_info, MIXED_GROUPS))

fs/btrfs/extent-tree.c

2788

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

fs/btrfs/extent-tree.c

2807

fetch_cluster_info(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

2817

ret = &fs_info->meta_alloc_cluster;

fs/btrfs/extent-tree.c

2818

if (btrfs_test_opt(fs_info, SSD))

fs/btrfs/extent-tree.c

2823

btrfs_test_opt(fs_info, SSD_SPREAD)) {

fs/btrfs/extent-tree.c

2825

ret = &fs_info->data_alloc_cluster;

fs/btrfs/extent-tree.c

2831

static int unpin_extent_range(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

2849

cache = btrfs_lookup_block_group(fs_info, start);

fs/btrfs/extent-tree.c

2855

cluster = fetch_cluster_info(fs_info,

fs/btrfs/extent-tree.c

2895

} else if (btrfs_is_zoned(fs_info)) {

fs/btrfs/extent-tree.c

2917

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/extent-tree.c

2921

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

fs/btrfs/extent-tree.c

2940

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

2945

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

2953

void btrfs_handle_fully_remapped_bgs(struct btrfs_fs_info *fs_info)

fs/btrfs/extent-tree.c

2958

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

2959

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

fs/btrfs/extent-tree.c

2960

bg = list_first_entry(&fs_info->fully_remapped_bgs,

fs/btrfs/extent-tree.c

2963

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

2965

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

fs/btrfs/extent-tree.c

2974

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

2976

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

2981

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

2991

mutex_lock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/extent-tree.c

2997

if (btrfs_test_opt(fs_info, DISCARD_SYNC)) {

fs/btrfs/extent-tree.c

2998

ret = btrfs_discard_extent(fs_info, start,

fs/btrfs/extent-tree.c

3001

btrfs_warn(fs_info,

fs/btrfs/extent-tree.c

3009

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

fs/btrfs/extent-tree.c

3019

btrfs_err_rl(fs_info,

fs/btrfs/extent-tree.c

3031

mutex_unlock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/extent-tree.c

3034

mutex_lock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/extent-tree.c

3045

mutex_unlock(&fs_info->unused_bg_unpin_mutex);

fs/btrfs/extent-tree.c

3048

if (btrfs_test_opt(fs_info, DISCARD_ASYNC)) {

fs/btrfs/extent-tree.c

3049

btrfs_discard_calc_delay(&fs_info->discard_ctl);

fs/btrfs/extent-tree.c

3050

btrfs_discard_schedule_work(&fs_info->discard_ctl, true);

fs/btrfs/extent-tree.c

3062

ret = btrfs_discard_extent(fs_info, block_group->start,

fs/btrfs/extent-tree.c

3070

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

3072

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/extent-tree.c

3079

btrfs_warn(fs_info,

fs/btrfs/extent-tree.c

3102

u64 btrfs_get_extent_owner_root(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

3112

if (!btrfs_fs_incompat(fs_info, SIMPLE_QUOTA))

fs/btrfs/extent-tree.c

3156

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

fs/btrfs/extent-tree.c

3160

btrfs_err(trans->fs_info,

fs/btrfs/extent-tree.c

3179

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

fs/btrfs/extent-tree.c

3205

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

fs/btrfs/extent-tree.c

3272

struct btrfs_fs_info *info = trans->fs_info;

fs/btrfs/extent-tree.c

3433

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

3543

delta.root = btrfs_get_extent_owner_root(trans->fs_info,

fs/btrfs/extent-tree.c

3570

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

3577

head = btrfs_find_delayed_ref_head(fs_info, delayed_refs, bytenr);

fs/btrfs/extent-tree.c

3595

btrfs_delete_ref_head(fs_info, delayed_refs, head);

fs/btrfs/extent-tree.c

3605

btrfs_cleanup_ref_head_accounting(fs_info, delayed_refs, head);

fs/btrfs/extent-tree.c

3622

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

3645

btrfs_ref_tree_mod(fs_info, &generic_ref);

fs/btrfs/extent-tree.c

366

ASSERT(fs_info);

fs/btrfs/extent-tree.c

3663

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

fs/btrfs/extent-tree.c

3688

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

fs/btrfs/extent-tree.c

3689

|| btrfs_is_zoned(fs_info)) {

fs/btrfs/extent-tree.c

3700

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

fs/btrfs/extent-tree.c

3708

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

371

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

fs/btrfs/extent-tree.c

3711

if (btrfs_is_testing(fs_info))

fs/btrfs/extent-tree.c

3728

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

4030

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/extent-tree.c

4042

ASSERT(btrfs_is_zoned(block_group->fs_info));

fs/btrfs/extent-tree.c

4048

spin_lock(&fs_info->treelog_bg_lock);

fs/btrfs/extent-tree.c

4049

log_bytenr = fs_info->treelog_bg;

fs/btrfs/extent-tree.c

4053

spin_unlock(&fs_info->treelog_bg_lock);

fs/btrfs/extent-tree.c

4061

spin_lock(&fs_info->relocation_bg_lock);

fs/btrfs/extent-tree.c

4062

data_reloc_bytenr = fs_info->data_reloc_bg;

fs/btrfs/extent-tree.c

4067

spin_unlock(&fs_info->relocation_bg_lock);

fs/btrfs/extent-tree.c

4094

spin_lock(&fs_info->treelog_bg_lock);

fs/btrfs/extent-tree.c

4095

spin_lock(&fs_info->relocation_bg_lock);

fs/btrfs/extent-tree.c

4101

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

fs/btrfs/extent-tree.c

4102

fs_info->treelog_bg == 0);

fs/btrfs/extent-tree.c

4104

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

fs/btrfs/extent-tree.c

4105

fs_info->data_reloc_bg == 0);

fs/btrfs/extent-tree.c

4118

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

fs/btrfs/extent-tree.c

4128

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

fs/btrfs/extent-tree.c

4149

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

fs/btrfs/extent-tree.c

4150

fs_info->treelog_bg = block_group->start;

fs/btrfs/extent-tree.c

4153

if (!fs_info->data_reloc_bg)

fs/btrfs/extent-tree.c

4154

fs_info->data_reloc_bg = block_group->start;

fs/btrfs/extent-tree.c

4188

fs_info->treelog_bg = 0;

fs/btrfs/extent-tree.c

4190

fs_info->data_reloc_bg = 0;

fs/btrfs/extent-tree.c

4191

spin_unlock(&fs_info->relocation_bg_lock);

fs/btrfs/extent-tree.c

4192

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

4373

ret = can_allocate_chunk(fs_info, ffe_ctl);

fs/btrfs/extent-tree.c

4423

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

4451

ffe_ctl->last_ptr = fetch_cluster_info(fs_info, space_info,

fs/btrfs/extent-tree.c

4474

static int prepare_allocation_zoned(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

4481

spin_lock(&fs_info->treelog_bg_lock);

fs/btrfs/extent-tree.c

4482

if (fs_info->treelog_bg)

fs/btrfs/extent-tree.c

4483

ffe_ctl->hint_byte = fs_info->treelog_bg;

fs/btrfs/extent-tree.c

4484

spin_unlock(&fs_info->treelog_bg_lock);

fs/btrfs/extent-tree.c

4489

spin_lock(&fs_info->relocation_bg_lock);

fs/btrfs/extent-tree.c

4490

if (fs_info->data_reloc_bg)

fs/btrfs/extent-tree.c

4491

ffe_ctl->hint_byte = fs_info->data_reloc_bg;

fs/btrfs/extent-tree.c

4492

spin_unlock(&fs_info->relocation_bg_lock);

fs/btrfs/extent-tree.c

4499

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/extent-tree.c

4500

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

fs/btrfs/extent-tree.c

4514

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/extent-tree.c

4519

static int prepare_allocation(struct btrfs_fs_info *fs_info,

fs/btrfs/extent-tree.c

452

btrfs_err(trans->fs_info,

fs/btrfs/extent-tree.c

4526

return prepare_allocation_clustered(fs_info, ffe_ctl,

fs/btrfs/extent-tree.c

4529

return prepare_allocation_zoned(fs_info, ffe_ctl, space_info);

fs/btrfs/extent-tree.c

4564

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

4571

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

fs/btrfs/extent-tree.c

4590

if (btrfs_is_zoned(fs_info))

fs/btrfs/extent-tree.c

4599

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

fs/btrfs/extent-tree.c

4600

if (btrfs_is_zoned(fs_info) && space_info) {

fs/btrfs/extent-tree.c

4611

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

fs/btrfs/extent-tree.c

4616

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

fs/btrfs/extent-tree.c

4621

first_logical_byte(fs_info));

fs/btrfs/extent-tree.c

4624

block_group = btrfs_lookup_block_group(fs_info,

fs/btrfs/extent-tree.c

4757

fs_info->stripesize);

fs/btrfs/extent-tree.c

4807

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

fs/btrfs/extent-tree.c

4879

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

4889

WARN_ON(num_bytes < fs_info->sectorsize);

fs/btrfs/extent-tree.c

4903

btrfs_dec_block_group_reservations(fs_info, ins->objectid);

fs/btrfs/extent-tree.c

4908

fs_info->sectorsize);

fs/btrfs/extent-tree.c

4914

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

fs/btrfs/extent-tree.c

4917

sinfo = btrfs_find_space_info(fs_info, flags);

fs/btrfs/extent-tree.c

4918

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

4929

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

fs/btrfs/extent-tree.c

4934

cache = btrfs_lookup_block_group(fs_info, start);

fs/btrfs/extent-tree.c

4936

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

fs/btrfs/extent-tree.c

4943

trace_btrfs_reserved_extent_free(fs_info, start, len);

fs/btrfs/extent-tree.c

4955

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

fs/btrfs/extent-tree.c

4957

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

fs/btrfs/extent-tree.c

4970

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

4980

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

fs/btrfs/extent-tree.c

4985

trace_btrfs_reserved_extent_alloc(fs_info, bytenr, num_bytes);

fs/btrfs/extent-tree.c

4994

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

5004

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

fs/btrfs/extent-tree.c

5016

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

fs/btrfs/extent-tree.c

5018

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

5074

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

5087

bool skinny_metadata = btrfs_fs_incompat(fs_info, SKINNY_METADATA);

fs/btrfs/extent-tree.c

5103

extent_root = btrfs_extent_root(fs_info, extent_key.objectid);

fs/btrfs/extent-tree.c

5105

btrfs_err(fs_info,

fs/btrfs/extent-tree.c

5152

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

fs/btrfs/extent-tree.c

5174

btrfs_ref_tree_mod(root->fs_info, &generic_ref);

fs/btrfs/extent-tree.c

5188

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/extent-tree.c

5204

if (!btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {

fs/btrfs/extent-tree.c

5205

ret = __exclude_logged_extent(fs_info, ins->objectid,

fs/btrfs/extent-tree.c

5211

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

5227

ret = btrfs_record_squota_delta(fs_info, &delta);

fs/btrfs/extent-tree.c

5240

btrfs_err_rl(eb->fs_info,

fs/btrfs/extent-tree.c

5259

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

5263

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

fs/btrfs/extent-tree.c

5309

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

fs/btrfs/extent-tree.c

5310

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

5347

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

5353

u32 blocksize = fs_info->nodesize;

fs/btrfs/extent-tree.c

5354

bool skinny_metadata = btrfs_fs_incompat(fs_info, SKINNY_METADATA);

fs/btrfs/extent-tree.c

5358

if (btrfs_is_testing(fs_info)) {

fs/btrfs/extent-tree.c

5421

btrfs_ref_tree_mod(fs_info, &generic_ref);

fs/btrfs/extent-tree.c

5434

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

fs/btrfs/extent-tree.c

5436

btrfs_unuse_block_rsv(fs_info, block_rsv, blocksize);

fs/btrfs/extent-tree.c

5551

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

5568

BTRFS_NODEPTRS_PER_BLOCK(fs_info));

fs/btrfs/extent-tree.c

5590

ret = btrfs_lookup_extent_info(trans, fs_info, bytenr,

fs/btrfs/extent-tree.c

5629

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

5646

ret = btrfs_lookup_extent_info(trans, fs_info,

fs/btrfs/extent-tree.c

5654

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

fs/btrfs/extent-tree.c

5723

root->fs_info->nodesize, parent,

fs/btrfs/extent-tree.c

5740

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

fs/btrfs/extent-tree.c

5826

.num_bytes = root->fs_info->nodesize,

fs/btrfs/extent-tree.c

5842

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

fs/btrfs/extent-tree.c

5874

btrfs_err_rl(root->fs_info,

fs/btrfs/extent-tree.c

5911

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

5934

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

fs/btrfs/extent-tree.c

5941

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

fs/btrfs/extent-tree.c

5949

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

fs/btrfs/extent-tree.c

5978

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

fs/btrfs/extent-tree.c

6022

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

6051

ret = btrfs_lookup_extent_info(trans, fs_info,

fs/btrfs/extent-tree.c

6063

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

fs/btrfs/extent-tree.c

6090

btrfs_err_rl(fs_info,

fs/btrfs/extent-tree.c

6127

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

6253

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

6256

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/extent-tree.c

6266

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

fs/btrfs/extent-tree.c

6346

ret = btrfs_lookup_extent_info(trans, fs_info,

fs/btrfs/extent-tree.c

6371

wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);

fs/btrfs/extent-tree.c

6405

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

fs/btrfs/extent-tree.c

6415

btrfs_set_last_root_drop_gen(fs_info, trans->transid);

fs/btrfs/extent-tree.c

6418

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

fs/btrfs/extent-tree.c

6419

btrfs_debug(fs_info,

fs/btrfs/extent-tree.c

6483

btrfs_set_last_root_drop_gen(fs_info, trans->transid);

fs/btrfs/extent-tree.c

6490

ret = btrfs_qgroup_cleanup_dropped_subvolume(fs_info, rootid);

fs/btrfs/extent-tree.c

6492

btrfs_warn_rl(fs_info,

fs/btrfs/extent-tree.c

6502

btrfs_maybe_wake_unfinished_drop(fs_info);

fs/btrfs/extent-tree.c

6527

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent-tree.c

6563

wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);

fs/btrfs/extent-tree.c

6585

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

fs/btrfs/extent-tree.c

6587

unpin_extent_range(fs_info, start, end, false);

fs/btrfs/extent-tree.c

6634

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/extent-tree.c

6640

ret = mutex_lock_interruptible(&fs_info->chunk_mutex);

fs/btrfs/extent-tree.c

6653

btrfs_warn(fs_info,

fs/btrfs/extent-tree.c

6658

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/extent-tree.c

6678

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/extent-tree.c

6688

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/extent-tree.c

6713

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

fs/btrfs/extent-tree.c

6718

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/extent-tree.c

6782

btrfs_warn(fs_info,

fs/btrfs/extent-tree.c

6838

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

fs/btrfs/extent-tree.c

6863

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

fs/btrfs/extent-tree.c

6904

btrfs_warn(fs_info,

fs/btrfs/extent-tree.c

691

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

fs/btrfs/extent-tree.c

6911

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

fs/btrfs/extent-tree.c

6915

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

1002

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/extent_io.c

1010

const size_t blocksize = fs_info->sectorsize;

fs/btrfs/extent_io.c

1031

begin_folio_read(fs_info, folio);

fs/btrfs/extent_io.c

1040

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

fs/btrfs/extent_io.c

1046

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

fs/btrfs/extent_io.c

1074

!btrfs_is_subpage(fs_info, folio) &&

fs/btrfs/extent_io.c

1176

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

fs/btrfs/extent_io.c

1178

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/extent_io.c

1218

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

fs/btrfs/extent_io.c

1227

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

fs/btrfs/extent_io.c

1240

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

fs/btrfs/extent_io.c

1248

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

fs/btrfs/extent_io.c

1370

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

1376

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

fs/btrfs/extent_io.c

1377

nbits = len >> fs_info->sectorsize_bits;

fs/btrfs/extent_io.c

1386

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

1388

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

fs/btrfs/extent_io.c

1395

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

fs/btrfs/extent_io.c

1400

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

fs/btrfs/extent_io.c

1402

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

fs/btrfs/extent_io.c

1425

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

fs/btrfs/extent_io.c

1427

const bool is_subpage = btrfs_is_subpage(fs_info, folio);

fs/btrfs/extent_io.c

1430

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

fs/btrfs/extent_io.c

1456

if (btrfs_is_subpage(fs_info, folio)) {

fs/btrfs/extent_io.c

1458

btrfs_get_subpage_dirty_bitmap(fs_info, folio, &bio_ctrl->submit_bitmap);

fs/btrfs/extent_io.c

1465

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

fs/btrfs/extent_io.c

1466

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

fs/btrfs/extent_io.c

1468

btrfs_folio_set_lock(fs_info, folio, start, len);

fs/btrfs/extent_io.c

1533

btrfs_err_rl(fs_info,

fs/btrfs/extent_io.c

1561

fs_info->sectorsize_bits;

fs/btrfs/extent_io.c

1563

page_start) >> fs_info->sectorsize_bits;

fs/btrfs/extent_io.c

1582

fs_info->sectorsize_bits,

fs/btrfs/extent_io.c

1587

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

fs/btrfs/extent_io.c

1588

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

fs/btrfs/extent_io.c

1638

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

fs/btrfs/extent_io.c

1644

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/extent_io.c

1665

btrfs_folio_clear_dirty(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1666

btrfs_folio_set_writeback(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1667

btrfs_folio_clear_writeback(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1674

fs_info->sectorsize, false);

fs/btrfs/extent_io.c

1700

btrfs_folio_clear_dirty(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1701

btrfs_folio_set_writeback(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

171

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

fs/btrfs/extent_io.c

1729

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

fs/btrfs/extent_io.c

1736

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

fs/btrfs/extent_io.c

1753

btrfs_folio_clear_dirty(fs_info, folio, start, len);

fs/btrfs/extent_io.c

1754

btrfs_folio_set_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

1755

btrfs_folio_clear_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

1759

bitmap_set(&range_bitmap, (start - folio_pos(folio)) >> fs_info->sectorsize_bits,

fs/btrfs/extent_io.c

1760

len >> fs_info->sectorsize_bits);

fs/btrfs/extent_io.c

1767

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

fs/btrfs/extent_io.c

1773

fs_info->sectorsize);

fs/btrfs/extent_io.c

1787

fs_info->sectorsize, true);

fs/btrfs/extent_io.c

1796

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

fs/btrfs/extent_io.c

1820

btrfs_folio_set_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

1821

btrfs_folio_clear_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

1838

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

fs/btrfs/extent_io.c

1843

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

fs/btrfs/extent_io.c

1881

btrfs_err_rl(fs_info,

fs/btrfs/extent_io.c

1904

btrfs_err_rl(fs_info,

fs/btrfs/extent_io.c

1919

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

fs/btrfs/extent_io.c

1934

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

1953

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

fs/btrfs/extent_io.c

1967

percpu_counter_add_batch(&fs_info->dirty_metadata_bytes,

fs/btrfs/extent_io.c

1969

fs_info->dirty_metadata_batch);

fs/btrfs/extent_io.c

1980

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

1996

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

fs/btrfs/extent_io.c

2038

set_bit(BTRFS_FS_BTREE_ERR, &fs_info->flags);

fs/btrfs/extent_io.c

2041

set_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags);

fs/btrfs/extent_io.c

2044

set_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags);

fs/btrfs/extent_io.c

2053

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

2054

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

fs/btrfs/extent_io.c

2065

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

2066

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

fs/btrfs/extent_io.c

2075

static void buffer_tree_tag_for_writeback(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

2078

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

fs/btrfs/extent_io.c

2155

static unsigned int buffer_tree_get_ebs_tag(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

2160

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

fs/btrfs/extent_io.c

2166

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

fs/btrfs/extent_io.c

2185

struct btrfs_fs_info *fs_info, u64 start)

fs/btrfs/extent_io.c

2188

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

fs/btrfs/extent_io.c

2191

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

fs/btrfs/extent_io.c

2236

end += BTRFS_LEAF_DATA_SIZE(eb->fs_info);

fs/btrfs/extent_io.c

2246

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

2253

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

fs/btrfs/extent_io.c

2256

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

fs/btrfs/extent_io.c

2278

if (unlikely(BTRFS_FS_ERROR(fs_info))) {

fs/btrfs/extent_io.c

2279

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

fs/btrfs/extent_io.c

2294

void btrfs_btree_wait_writeback_range(struct btrfs_fs_info *fs_info, u64 start,

fs/btrfs/extent_io.c

2298

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

fs/btrfs/extent_io.c

2299

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

fs/btrfs/extent_io.c

2306

nr_ebs = buffer_tree_get_ebs_tag(fs_info, &start_index, end_index,

fs/btrfs/extent_io.c

2321

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

fs/btrfs/extent_io.c

2334

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

fs/btrfs/extent_io.c

2343

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

fs/btrfs/extent_io.c

2344

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

fs/btrfs/extent_io.c

2352

btrfs_zoned_meta_io_lock(fs_info);

fs/btrfs/extent_io.c

2355

buffer_tree_tag_for_writeback(fs_info, index, end);

fs/btrfs/extent_io.c

2357

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

fs/btrfs/extent_io.c

2363

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

fs/btrfs/extent_io.c

243

static void process_one_folio(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

2431

if (!ret && BTRFS_FS_ERROR(fs_info))

fs/btrfs/extent_io.c

2436

btrfs_zoned_meta_io_unlock(fs_info);

fs/btrfs/extent_io.c

253

btrfs_folio_clamp_set_ordered(fs_info, folio, start, len);

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

2634

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/extent_io.c

2635

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/extent_io.c

2688

btrfs_folio_end_lock(fs_info, folio, cur, cur_len);

fs/btrfs/extent_io.c

269

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

fs/btrfs/extent_io.c

284

process_one_folio(fs_info, folio, locked_folio,

fs/btrfs/extent_io.c

2840

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

fs/btrfs/extent_io.c

2931

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

2948

if (!btrfs_meta_is_subpage(fs_info)) {

fs/btrfs/extent_io.c

2973

btrfs_detach_folio_state(fs_info, folio, BTRFS_SUBPAGE_METADATA);

fs/btrfs/extent_io.c

2977

btrfs_folio_dec_eb_refs(fs_info, folio);

fs/btrfs/extent_io.c

2984

btrfs_detach_folio_state(fs_info, folio, BTRFS_SUBPAGE_METADATA);

fs/btrfs/extent_io.c

3014

static struct extent_buffer *__alloc_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

3021

eb->len = fs_info->nodesize;

fs/btrfs/extent_io.c

3022

eb->fs_info = fs_info;

fs/btrfs/extent_io.c

3059

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

fs/btrfs/extent_io.c

306

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/extent_io.c

3101

struct extent_buffer *alloc_dummy_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

3107

eb = __alloc_extent_buffer(fs_info, start);

fs/btrfs/extent_io.c

3179

struct extent_buffer *find_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

3184

eb = find_extent_buffer_nolock(fs_info, start);

fs/btrfs/extent_io.c

3208

struct extent_buffer *alloc_test_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

3215

eb = find_extent_buffer(fs_info, start);

fs/btrfs/extent_io.c

3218

eb = alloc_dummy_extent_buffer(fs_info, start);

fs/btrfs/extent_io.c

3221

eb->fs_info = fs_info;

fs/btrfs/extent_io.c

3223

xa_lock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3224

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

fs/btrfs/extent_io.c

3228

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3235

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3238

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3242

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3252

static struct extent_buffer *grab_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

3264

if (btrfs_meta_is_subpage(fs_info))

fs/btrfs/extent_io.c

3289

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

fs/btrfs/extent_io.c

3291

const u32 nodesize = fs_info->nodesize;

fs/btrfs/extent_io.c

3293

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

fs/btrfs/extent_io.c

3294

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

fs/btrfs/extent_io.c

3299

btrfs_err(fs_info,

fs/btrfs/extent_io.c

3305

btrfs_err(fs_info,

fs/btrfs/extent_io.c

3311

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

fs/btrfs/extent_io.c

3312

btrfs_warn(fs_info,

fs/btrfs/extent_io.c

3332

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

3333

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

fs/btrfs/extent_io.c

3366

if (existing_folio && btrfs_meta_is_subpage(fs_info)) {

fs/btrfs/extent_io.c

337

btrfs_folio_set_lock(fs_info, folio, range_start, range_len);

fs/btrfs/extent_io.c

3373

existing_eb = grab_extent_buffer(fs_info, existing_folio);

fs/btrfs/extent_io.c

3400

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

fs/btrfs/extent_io.c

3405

struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

3417

if (check_eb_alignment(fs_info, start))

fs/btrfs/extent_io.c

3422

btrfs_err_rl(fs_info,

fs/btrfs/extent_io.c

3424

btrfs_err_32bit_limit(fs_info);

fs/btrfs/extent_io.c

3428

btrfs_warn_32bit_limit(fs_info);

fs/btrfs/extent_io.c

3431

eb = find_extent_buffer(fs_info, start);

fs/btrfs/extent_io.c

3435

eb = __alloc_extent_buffer(fs_info, start);

fs/btrfs/extent_io.c

3455

if (btrfs_meta_is_subpage(fs_info)) {

fs/btrfs/extent_io.c

3456

prealloc = btrfs_alloc_folio_state(fs_info, PAGE_SIZE, BTRFS_SUBPAGE_METADATA);

fs/btrfs/extent_io.c

3539

xa_lock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3540

existing_eb = __xa_cmpxchg(&fs_info->buffer_tree,

fs/btrfs/extent_io.c

3541

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

fs/btrfs/extent_io.c

3545

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3550

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3553

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3556

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/extent_io.c

3625

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

3643

xa_cmpxchg_irq(&fs_info->buffer_tree,

fs/btrfs/extent_io.c

3644

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

fs/btrfs/extent_io.c

3726

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

373

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/extent_io.c

3742

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

fs/btrfs/extent_io.c

3751

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

fs/btrfs/extent_io.c

3752

fs_info->dirty_metadata_batch);

fs/btrfs/extent_io.c

377

u64 max_bytes = fs_info->max_extent_size;

fs/btrfs/extent_io.c

3782

bool subpage = btrfs_meta_is_subpage(eb->fs_info);

fs/btrfs/extent_io.c

3802

percpu_counter_add_batch(&eb->fs_info->dirty_metadata_bytes,

fs/btrfs/extent_io.c

3804

eb->fs_info->dirty_metadata_batch);

fs/btrfs/extent_io.c

3871

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

3905

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

fs/btrfs/extent_io.c

3940

btrfs_warn(eb->fs_info,

fs/btrfs/extent_io.c

400

ASSERT(max_bytes >= fs_info->sectorsize);

fs/btrfs/extent_io.c

4089

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

4105

if (btrfs_meta_is_subpage(fs_info)) {

fs/btrfs/extent_io.c

4108

if (WARN_ON(!btrfs_subpage_test_uptodate(fs_info, folio,

fs/btrfs/extent_io.c

4110

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

fs/btrfs/extent_io.c

43

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

439

max_bytes = fs_info->sectorsize;

fs/btrfs/extent_io.c

4481

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

4483

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

fs/btrfs/extent_io.c

4485

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

fs/btrfs/extent_io.c

4489

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

fs/btrfs/extent_io.c

4595

void btrfs_readahead_tree_block(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.c

46

spin_lock_irqsave(&fs_info->eb_leak_lock, flags);

fs/btrfs/extent_io.c

4605

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

fs/btrfs/extent_io.c

4632

btrfs_readahead_tree_block(node->fs_info,

fs/btrfs/extent_io.c

47

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

fs/btrfs/extent_io.c

48

spin_unlock_irqrestore(&fs_info->eb_leak_lock, flags);

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

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

523

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/extent_io.c

53

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

533

btrfs_err(fs_info,

fs/btrfs/extent_io.c

537

btrfs_info(fs_info,

fs/btrfs/extent_io.c

545

btrfs_folio_clear_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

551

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

fs/btrfs/extent_io.c

554

if (!btrfs_is_subpage(fs_info, folio))

fs/btrfs/extent_io.c

558

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

fs/btrfs/extent_io.c

56

spin_lock_irqsave(&fs_info->eb_leak_lock, flags);

fs/btrfs/extent_io.c

575

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

fs/btrfs/extent_io.c

58

spin_unlock_irqrestore(&fs_info->eb_leak_lock, flags);

fs/btrfs/extent_io.c

591

btrfs_debug(fs_info,

fs/btrfs/extent_io.c

61

void btrfs_extent_buffer_leak_debug_check(struct btrfs_fs_info *fs_info)

fs/btrfs/extent_io.c

70

if (!fs_info->allocated_ebs.next)

fs/btrfs/extent_io.c

73

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

fs/btrfs/extent_io.c

74

spin_lock_irqsave(&fs_info->eb_leak_lock, flags);

fs/btrfs/extent_io.c

742

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

fs/btrfs/extent_io.c

75

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

fs/btrfs/extent_io.c

76

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

78

btrfs_err(fs_info,

fs/btrfs/extent_io.c

86

spin_unlock_irqrestore(&fs_info->eb_leak_lock, flags);

fs/btrfs/extent_io.c

873

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/extent_io.c

885

if (!btrfs_meta_is_subpage(fs_info)) {

fs/btrfs/extent_io.c

904

ret = btrfs_attach_folio_state(fs_info, folio, BTRFS_SUBPAGE_METADATA);

fs/btrfs/extent_io.c

910

struct btrfs_fs_info *fs_info;

fs/btrfs/extent_io.c

917

fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

919

if (btrfs_is_subpage(fs_info, folio))

fs/btrfs/extent_io.c

920

return btrfs_attach_folio_state(fs_info, folio, BTRFS_SUBPAGE_DATA);

fs/btrfs/extent_io.c

928

struct btrfs_fs_info *fs_info;

fs/btrfs/extent_io.c

935

fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

936

if (btrfs_is_subpage(fs_info, folio))

fs/btrfs/extent_io.c

937

return btrfs_detach_folio_state(fs_info, folio, BTRFS_SUBPAGE_DATA);

fs/btrfs/extent_io.h

241

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

fs/btrfs/extent_io.h

246

struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.h

248

struct extent_buffer *alloc_dummy_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.h

251

struct extent_buffer *find_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.h

266

void btrfs_readahead_tree_block(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.h

375

struct extent_buffer *alloc_test_extent_buffer(struct btrfs_fs_info *fs_info,

fs/btrfs/extent_io.h

379

void btrfs_extent_buffer_leak_debug_check(struct btrfs_fs_info *fs_info);

fs/btrfs/extent_io.h

381

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

fs/btrfs/extent_io.h

91

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

1258

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/extent_map.c

1261

u64 min_ino = fs_info->em_shrinker_last_ino + 1;

fs/btrfs/extent_map.c

1269

fs_info->em_shrinker_last_ino = btrfs_ino(inode);

fs/btrfs/extent_map.c

1272

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

fs/btrfs/extent_map.c

1288

fs_info->em_shrinker_last_root = btrfs_root_id(root);

fs/btrfs/extent_map.c

1294

fs_info->em_shrinker_last_ino = 0;

fs/btrfs/extent_map.c

1295

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

fs/btrfs/extent_map.c

1303

struct btrfs_fs_info *fs_info;

fs/btrfs/extent_map.c

1310

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

fs/btrfs/extent_map.c

1313

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

fs/btrfs/extent_map.c

1315

start_root_id = fs_info->em_shrinker_last_root;

fs/btrfs/extent_map.c

1316

next_root_id = fs_info->em_shrinker_last_root;

fs/btrfs/extent_map.c

1319

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

fs/btrfs/extent_map.c

1321

trace_btrfs_extent_map_shrinker_scan_enter(fs_info, nr);

fs/btrfs/extent_map.c

1324

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

fs/btrfs/extent_map.c

1330

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/extent_map.c

1331

count = radix_tree_gang_lookup(&fs_info->fs_roots_radix,

fs/btrfs/extent_map.c

1335

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/extent_map.c

1338

fs_info->em_shrinker_last_root = 0;

fs/btrfs/extent_map.c

1339

fs_info->em_shrinker_last_ino = 0;

fs/btrfs/extent_map.c

1347

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/extent_map.c

1359

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

fs/btrfs/extent_map.c

1361

trace_btrfs_extent_map_shrinker_scan_exit(fs_info, nr_dropped, nr);

fs/btrfs/extent_map.c

1364

atomic64_set(&fs_info->em_shrinker_nr_to_scan, 0);

fs/btrfs/extent_map.c

1367

void btrfs_free_extent_maps(struct btrfs_fs_info *fs_info, long nr_to_scan)

fs/btrfs/extent_map.c

1384

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

fs/btrfs/extent_map.c

1387

queue_work(system_dfl_wq, &fs_info->em_shrinker_work);

fs/btrfs/extent_map.c

1390

void btrfs_init_extent_map_shrinker_work(struct btrfs_fs_info *fs_info)

fs/btrfs/extent_map.c

1392

atomic64_set(&fs_info->em_shrinker_nr_to_scan, 0);

fs/btrfs/extent_map.c

1393

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

1104

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file-item.c

1119

const u32 csum_size = fs_info->csum_size;

fs/btrfs/file-item.c

1152

MAX_CSUM_ITEMS(fs_info, csum_size)) {

fs/btrfs/file-item.c

1178

fs_info->sectorsize_bits;

fs/btrfs/file-item.c

1198

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

fs/btrfs/file-item.c

1202

csum_offset >= MAX_CSUM_ITEMS(fs_info, csum_size)) {

fs/btrfs/file-item.c

121

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

fs/btrfs/file-item.c

1214

tmp >>= fs_info->sectorsize_bits;

fs/btrfs/file-item.c

1253

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

fs/btrfs/file-item.c

1260

MAX_CSUM_ITEMS(fs_info, csum_size) * csum_size);

fs/btrfs/file-item.c

1279

tmp >>= 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

1281

fs_info->sectorsize_bits);

fs/btrfs/file-item.c

1284

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

fs/btrfs/file-item.c

130

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

fs/btrfs/file-item.c

1301

ins_size = (u32)(sums->len - total_bytes) >> fs_info->sectorsize_bits;

fs/btrfs/file-item.c

1310

total_bytes += ins_size * fs_info->sectorsize;

fs/btrfs/file-item.c

132

return (bytes >> fs_info->sectorsize_bits) * fs_info->csum_size;

fs/btrfs/file-item.c

1326

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

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

137

ASSERT(IS_ALIGNED(csum_size, fs_info->csum_size));

fs/btrfs/file-item.c

1373

em->len = fs_info->sectorsize;

fs/btrfs/file-item.c

1377

btrfs_err(fs_info,

fs/btrfs/file-item.c

139

return (csum_size / fs_info->csum_size) << fs_info->sectorsize_bits;

fs/btrfs/file-item.c

1402

end = leaf->fs_info->sectorsize;

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

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

332

disk_bytenr) >> fs_info->sectorsize_bits;

fs/btrfs/file-item.c

349

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

fs/btrfs/file-item.c

352

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/file-item.c

353

const u32 csum_size = fs_info->csum_size;

fs/btrfs/file-item.c

356

const unsigned int nblocks = orig_len >> fs_info->sectorsize_bits;

fs/btrfs/file-item.c

361

test_bit(BTRFS_FS_STATE_NO_DATA_CSUMS, &fs_info->fs_state))

fs/btrfs/file-item.c

393

if (nblocks > fs_info->csums_per_leaf)

fs/btrfs/file-item.c

434

down_read(&fs_info->commit_root_sem);

fs/btrfs/file-item.c

441

(bio_offset >> fs_info->sectorsize_bits) * csum_size;

fs/btrfs/file-item.c

443

count = search_csum_tree(fs_info, path, cur_disk_bytenr,

fs/btrfs/file-item.c

474

btrfs_warn_rl(fs_info,

fs/btrfs/file-item.c

483

up_read(&fs_info->commit_root_sem);

fs/btrfs/file-item.c

504

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file-item.c

513

ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&

fs/btrfs/file-item.c

514

IS_ALIGNED(end + 1, fs_info->sectorsize));

fs/btrfs/file-item.c

550

if (bytes_to_csum_size(fs_info, start - key.offset) <

fs/btrfs/file-item.c

578

csum_end = key.offset + csum_size_to_bytes(fs_info,

fs/btrfs/file-item.c

597

max_ordered_sum_bytes(fs_info));

fs/btrfs/file-item.c

598

sums = kzalloc(btrfs_ordered_sum_size(fs_info, size),

fs/btrfs/file-item.c

608

offset = bytes_to_csum_size(fs_info, start - key.offset);

fs/btrfs/file-item.c

613

bytes_to_csum_size(fs_info, size));

fs/btrfs/file-item.c

649

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file-item.c

657

ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&

fs/btrfs/file-item.c

658

IS_ALIGNED(end + 1, fs_info->sectorsize));

fs/btrfs/file-item.c

706

if (bytes_to_csum_size(fs_info, start - key.offset) <

fs/btrfs/file-item.c

735

csum_end = key.offset + csum_size_to_bytes(fs_info,

fs/btrfs/file-item.c

748

u8 *csum_dest = csum_buf + bytes_to_csum_size(fs_info,

fs/btrfs/file-item.c

753

offset = bytes_to_csum_size(fs_info, start - key.offset);

fs/btrfs/file-item.c

757

bytes_to_csum_size(fs_info, size));

fs/btrfs/file-item.c

760

(start - orig_start) >> fs_info->sectorsize_bits,

fs/btrfs/file-item.c

761

size >> fs_info->sectorsize_bits);

fs/btrfs/file-item.c

777

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

fs/btrfs/file-item.c

782

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/file-item.c

794

btrfs_calculate_block_csum_pages(fs_info, paddrs, sums->sums + index);

fs/btrfs/file-item.c

795

index += fs_info->csum_size;

fs/btrfs/file-item.c

817

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

fs/btrfs/file-item.c

823

sums = kvzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size),

fs/btrfs/file-item.c

881

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/file-item.c

883

const u32 csum_size = fs_info->csum_size;

fs/btrfs/file-item.c

886

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

929

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/file-item.c

936

const u32 csum_size = fs_info->csum_size;

fs/btrfs/file-item.c

937

u32 blocksize_bits = fs_info->sectorsize_bits;

fs/btrfs/file.c

1049

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/file.c

1082

loff_t end_pos = round_up(pos + count, fs_info->sectorsize);

fs/btrfs/file.c

109

btrfs_folio_clamp_set_uptodate(fs_info, folio, start_pos, num_bytes);

fs/btrfs/file.c

110

btrfs_folio_clamp_clear_checked(fs_info, folio, start_pos, num_bytes);

fs/btrfs/file.c

1102

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

fs/btrfs/file.c

1105

round_down(start, fs_info->sectorsize),

fs/btrfs/file.c

111

btrfs_folio_clamp_set_dirty(fs_info, folio, start_pos, num_bytes);

fs/btrfs/file.c

1121

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

fs/btrfs/file.c

1122

const unsigned int block_offset = (start & (fs_info->sectorsize - 1));

fs/btrfs/file.c

1147

reserve_bytes = round_up(*len + block_offset, fs_info->sectorsize);

fs/btrfs/file.c

1203

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

fs/btrfs/file.c

1207

const u64 reserved_start = round_down(start, fs_info->sectorsize);

fs/btrfs/file.c

1308

btrfs_drop_folio(fs_info, folio, start, copied);

fs/btrfs/file.c

1313

last_block = round_up(start + copied, fs_info->sectorsize);

fs/btrfs/file.c

1337

btrfs_drop_folio(fs_info, folio, start, copied);

fs/btrfs/file.c

1345

btrfs_drop_folio(fs_info, folio, start, copied);

fs/btrfs/file.c

142

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file.c

1441

if (btrfs_is_shutdown(inode->root->fs_info))

fs/btrfs/file.c

1448

if (BTRFS_FS_ERROR(inode->root->fs_info))

fs/btrfs/file.c

1525

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

fs/btrfs/file.c

1527

if (btrfs_inode_in_log(inode, btrfs_get_fs_generation(fs_info)) &&

fs/btrfs/file.c

1538

if (inode->last_trans <= btrfs_get_last_trans_committed(fs_info) &&

fs/btrfs/file.c

1562

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file.c

1661

if (full_sync || btrfs_is_zoned(fs_info)) {

fs/btrfs/file.c

1856

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

fs/btrfs/file.c

1951

reserved_space = round_up(size - page_start, fs_info->sectorsize);

fs/btrfs/file.c

1990

btrfs_folio_clear_checked(fs_info, folio, page_start, fsize);

fs/btrfs/file.c

1991

btrfs_folio_set_dirty(fs_info, folio, page_start, end + 1 - page_start);

fs/btrfs/file.c

1992

btrfs_folio_set_uptodate(fs_info, folio, page_start, end + 1 - page_start);

fs/btrfs/file.c

2090

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/file.c

2098

if (btrfs_fs_incompat(fs_info, NO_HOLES))

fs/btrfs/file.c

2187

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

fs/btrfs/file.c

2192

round_down(*start, fs_info->sectorsize),

fs/btrfs/file.c

2193

round_up(*len, fs_info->sectorsize));

fs/btrfs/file.c

2308

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/file.c

2320

btrfs_fs_incompat(fs_info, NO_HOLES)) {

fs/btrfs/file.c

2404

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/file.c

2405

u64 min_size = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/file.c

2406

u64 ino_size = round_up(inode->vfs_inode.i_size, fs_info->sectorsize);

fs/btrfs/file.c

2417

btrfs_init_metadata_block_rsv(fs_info, &rsv, BTRFS_BLOCK_RSV_TEMP);

fs/btrfs/file.c

2418

rsv.size = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/file.c

2427

if (!btrfs_fs_incompat(fs_info, NO_HOLES) || extent_info)

fs/btrfs/file.c

2439

ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, &rsv,

fs/btrfs/file.c

2472

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/file.c

2549

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/file.c

2558

ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv,

fs/btrfs/file.c

2589

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/file.c

2641

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/file.c

2647

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

fs/btrfs/file.c

2654

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/file.c

2677

ino_size = round_up(inode->i_size, fs_info->sectorsize);

fs/btrfs/file.c

2691

lockstart = round_up(offset, fs_info->sectorsize);

fs/btrfs/file.c

2692

lockend = round_down(offset + len, fs_info->sectorsize) - 1;

fs/btrfs/file.c

2693

same_block = (BTRFS_BYTES_TO_BLKS(fs_info, offset))

fs/btrfs/file.c

2694

== (BTRFS_BYTES_TO_BLKS(fs_info, offset + len - 1));

fs/btrfs/file.c

2699

if (same_block && len < fs_info->sectorsize) {

fs/btrfs/file.c

2783

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/file.c

2868

range_start = round_down(i_size_read(inode), root->fs_info->sectorsize);

fs/btrfs/file.c

2869

range_end = round_up(end, root->fs_info->sectorsize);

fs/btrfs/file.c

2898

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

fs/btrfs/file.c

2923

struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;

fs/btrfs/file.c

2928

const u64 sectorsize = fs_info->sectorsize;

fs/btrfs/file.c

2977

if (BTRFS_BYTES_TO_BLKS(fs_info, offset) ==

fs/btrfs/file.c

2978

BTRFS_BYTES_TO_BLKS(fs_info, offset + len - 1)) {

fs/btrfs/file.c

3075

fs_info->sectorsize,

fs/btrfs/file.c

3115

int blocksize = BTRFS_I(inode)->root->fs_info->sectorsize;

fs/btrfs/file.c

3424

u64 cur_offset = round_down(start, inode->root->fs_info->sectorsize);

fs/btrfs/file.c

3535

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

fs/btrfs/file.c

3612

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

fs/btrfs/file.c

3613

lockend = round_up(i_size, fs_info->sectorsize);

fs/btrfs/file.c

3615

lockend = lockstart + fs_info->sectorsize;

fs/btrfs/file.c

415

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

59

btrfs_folio_clamp_clear_checked(fs_info, folio, block_start, block_len);

fs/btrfs/file.c

74

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

fs/btrfs/file.c

89

start_pos = round_down(pos, fs_info->sectorsize);

fs/btrfs/file.c

90

num_bytes = round_up(end_pos - start_pos, fs_info->sectorsize);

fs/btrfs/file.c

903

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

fs/btrfs/file.c

908

start_pos = round_down(pos, fs_info->sectorsize);

fs/btrfs/file.c

909

last_pos = round_up(pos + write_bytes, fs_info->sectorsize) - 1;

fs/btrfs/file.c

980

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

fs/btrfs/file.c

993

lockstart = round_down(pos, fs_info->sectorsize);

fs/btrfs/file.c

995

fs_info->sectorsize) - 1;

fs/btrfs/free-space-cache.c

1017

ret = __load_free_space_cache(fs_info->tree_root, inode, &tmp_ctl,

fs/btrfs/free-space-cache.c

1044

btrfs_warn(fs_info,

fs/btrfs/free-space-cache.c

1057

btrfs_warn(fs_info,

fs/btrfs/free-space-cache.c

1314

btrfs_debug(root->fs_info,

fs/btrfs/free-space-cache.c

1351

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

1518

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/free-space-cache.c

1536

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

2258

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.c

2282

if (info->bytes <= fs_info->sectorsize * 8) {

fs/btrfs/free-space-cache.c

231

ret = btrfs_get_free_objectid(trans->fs_info->tree_root, &ino);

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

2621

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.c

2627

ASSERT(!btrfs_is_zoned(fs_info));

fs/btrfs/free-space-cache.c

2675

btrfs_crit(fs_info, "unable to add free space :%d", ret);

fs/btrfs/free-space-cache.c

2681

btrfs_discard_queue_work(&fs_info->discard_ctl, block_group);

fs/btrfs/free-space-cache.c

2756

if (btrfs_is_zoned(block_group->fs_info))

fs/btrfs/free-space-cache.c

2760

if (btrfs_test_opt(block_group->fs_info, DISCARD_SYNC))

fs/btrfs/free-space-cache.c

2769

if (btrfs_is_zoned(block_group->fs_info))

fs/btrfs/free-space-cache.c

2786

if (btrfs_is_zoned(block_group->fs_info))

fs/btrfs/free-space-cache.c

2790

if (btrfs_test_opt(block_group->fs_info, DISCARD_SYNC) ||

fs/btrfs/free-space-cache.c

2791

btrfs_test_opt(block_group->fs_info, DISCARD_ASYNC))

fs/btrfs/free-space-cache.c

2805

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

2913

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.c

2923

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/free-space-cache.c

2924

btrfs_info(fs_info, "free space %llu active %d",

fs/btrfs/free-space-cache.c

2936

btrfs_crit(fs_info, "entry offset %llu, bytes %llu, bitmap %s",

fs/btrfs/free-space-cache.c

2940

btrfs_info(fs_info, "block group has cluster?: %s",

fs/btrfs/free-space-cache.c

2942

btrfs_info(fs_info,

fs/btrfs/free-space-cache.c

2950

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.c

2953

ctl->unit = fs_info->sectorsize;

fs/btrfs/free-space-cache.c

3093

&block_group->fs_info->discard_ctl;

fs/btrfs/free-space-cache.c

3102

ASSERT(!btrfs_is_zoned(block_group->fs_info));

fs/btrfs/free-space-cache.c

3185

btrfs_discard_queue_work(&block_group->fs_info->discard_ctl, block_group);

fs/btrfs/free-space-cache.c

3230

&block_group->fs_info->discard_ctl;

fs/btrfs/free-space-cache.c

3235

ASSERT(!btrfs_is_zoned(block_group->fs_info));

fs/btrfs/free-space-cache.c

3564

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.c

3578

if (btrfs_test_opt(fs_info, SSD_SPREAD)) {

fs/btrfs/free-space-cache.c

3583

min_bytes = fs_info->sectorsize;

fs/btrfs/free-space-cache.c

3586

min_bytes = fs_info->sectorsize;

fs/btrfs/free-space-cache.c

3659

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.c

3680

ret = btrfs_discard_extent(fs_info, start, bytes, &trimmed, false);

fs/btrfs/free-space-cache.c

3722

&block_group->fs_info->discard_ctl;

fs/btrfs/free-space-cache.c

3839

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/free-space-cache.c

3840

struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl;

fs/btrfs/free-space-cache.c

3850

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/free-space-cache.c

3855

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/free-space-cache.c

3869

ret = btrfs_discard_extent(fs_info, bg->discard_cursor, bytes, &trimmed, false);

fs/btrfs/free-space-cache.c

3932

&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

4077

ASSERT(!btrfs_is_zoned(block_group->fs_info));

fs/btrfs/free-space-cache.c

4149

bool btrfs_free_space_cache_v1_active(struct btrfs_fs_info *fs_info)

fs/btrfs/free-space-cache.c

4151

return btrfs_super_cache_generation(fs_info->super_copy);

fs/btrfs/free-space-cache.c

4154

static int cleanup_free_space_cache_v1(struct btrfs_fs_info *fs_info,

fs/btrfs/free-space-cache.c

4160

btrfs_info(fs_info, "cleaning free space cache v1");

fs/btrfs/free-space-cache.c

4162

node = rb_first_cached(&fs_info->block_group_cache_tree);

fs/btrfs/free-space-cache.c

4175

int btrfs_set_free_space_cache_v1_active(struct btrfs_fs_info *fs_info, bool active)

fs/btrfs/free-space-cache.c

4188

trans = btrfs_start_transaction(fs_info->tree_root, 0);

fs/btrfs/free-space-cache.c

4193

set_bit(BTRFS_FS_CLEANUP_SPACE_CACHE_V1, &fs_info->flags);

fs/btrfs/free-space-cache.c

4194

ret = cleanup_free_space_cache_v1(fs_info, trans);

fs/btrfs/free-space-cache.c

4204

clear_bit(BTRFS_FS_CLEANUP_SPACE_CACHE_V1, &fs_info->flags);

fs/btrfs/free-space-cache.c

436

btrfs_folio_clear_checked(io_ctl->fs_info,

fs/btrfs/free-space-cache.c

477

btrfs_err(BTRFS_I(inode)->root->fs_info,

fs/btrfs/free-space-cache.c

483

btrfs_err(BTRFS_I(inode)->root->fs_info,

fs/btrfs/free-space-cache.c

525

btrfs_err_rl(io_ctl->fs_info,

fs/btrfs/free-space-cache.c

569

btrfs_err_rl(io_ctl->fs_info,

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

942

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-cache.h

103

struct btrfs_fs_info *fs_info;

fs/btrfs/free-space-cache.h

171

bool btrfs_free_space_cache_v1_active(struct btrfs_fs_info *fs_info);

fs/btrfs/free-space-cache.h

172

int btrfs_set_free_space_cache_v1_active(struct btrfs_fs_info *fs_info, bool active);

fs/btrfs/free-space-tree.c

100

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-tree.c

1018

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

fs/btrfs/free-space-tree.c

1028

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

fs/btrfs/free-space-tree.c

1076

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

fs/btrfs/free-space-tree.c

1078

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

1134

start += trans->fs_info->nodesize;

fs/btrfs/free-space-tree.c

1160

int btrfs_create_free_space_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/free-space-tree.c

1163

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/free-space-tree.c

1173

set_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);

fs/btrfs/free-space-tree.c

1174

set_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags);

fs/btrfs/free-space-tree.c

1191

node = rb_first_cached(&fs_info->block_group_cache_tree);

fs/btrfs/free-space-tree.c

1204

btrfs_set_fs_compat_ro(fs_info, FREE_SPACE_TREE);

fs/btrfs/free-space-tree.c

1205

btrfs_set_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID);

fs/btrfs/free-space-tree.c

1206

clear_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);

fs/btrfs/free-space-tree.c

1213

clear_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags);

fs/btrfs/free-space-tree.c

1217

clear_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);

fs/btrfs/free-space-tree.c

1218

clear_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags);

fs/btrfs/free-space-tree.c

1256

node = rb_first_cached(&trans->fs_info->block_group_cache_tree);

fs/btrfs/free-space-tree.c

1269

int btrfs_delete_free_space_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/free-space-tree.c

1272

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/free-space-tree.c

1278

struct btrfs_root *free_space_root = btrfs_global_root(fs_info, &key);

fs/btrfs/free-space-tree.c

1285

btrfs_clear_fs_compat_ro(fs_info, FREE_SPACE_TREE);

fs/btrfs/free-space-tree.c

1286

btrfs_clear_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID);

fs/btrfs/free-space-tree.c

1304

spin_lock(&fs_info->trans_lock);

fs/btrfs/free-space-tree.c

1306

spin_unlock(&fs_info->trans_lock);

fs/btrfs/free-space-tree.c

1323

int btrfs_rebuild_free_space_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/free-space-tree.c

1331

struct btrfs_root *free_space_root = btrfs_global_root(fs_info, &key);

fs/btrfs/free-space-tree.c

1339

set_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);

fs/btrfs/free-space-tree.c

1340

set_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags);

fs/btrfs/free-space-tree.c

1349

node = rb_first_cached(&fs_info->block_group_cache_tree);

fs/btrfs/free-space-tree.c

1376

btrfs_set_fs_compat_ro(fs_info, FREE_SPACE_TREE);

fs/btrfs/free-space-tree.c

1377

btrfs_set_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID);

fs/btrfs/free-space-tree.c

1378

clear_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);

fs/btrfs/free-space-tree.c

1381

clear_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags);

fs/btrfs/free-space-tree.c

1451

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

fs/btrfs/free-space-tree.c

1471

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

1541

struct btrfs_fs_info *fs_info = block_group->fs_info;

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

1594

offset += fs_info->sectorsize;

fs/btrfs/free-space-tree.c

1605

btrfs_err(fs_info,

fs/btrfs/free-space-tree.c

1621

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-tree.c

1662

btrfs_err(fs_info,

fs/btrfs/free-space-tree.c

1754

btrfs_info(fst_root->fs_info, "deleted orphan free space tree entries");

fs/btrfs/free-space-tree.c

1759

int btrfs_delete_orphan_free_space_entries(struct btrfs_fs_info *fs_info)

fs/btrfs/free-space-tree.c

1778

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))

fs/btrfs/free-space-tree.c

1780

if (!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE))

fs/btrfs/free-space-tree.c

1782

root = btrfs_global_root(fs_info, &key);

fs/btrfs/free-space-tree.c

1790

bg = btrfs_lookup_first_block_group(fs_info, 0);

fs/btrfs/free-space-tree.c

1792

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

215

bitmap_size = free_space_bitmap_size(fs_info, block_group->length);

fs/btrfs/free-space-tree.c

253

fs_info->sectorsize);

fs/btrfs/free-space-tree.c

255

fs_info->sectorsize);

fs/btrfs/free-space-tree.c

290

btrfs_err(fs_info,

fs/btrfs/free-space-tree.c

300

bitmap_range = fs_info->sectorsize * BTRFS_FREE_SPACE_BITMAP_BITS;

fs/btrfs/free-space-tree.c

308

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

342

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/free-space-tree.c

355

bitmap_size = free_space_bitmap_size(fs_info, block_group->length);

fs/btrfs/free-space-tree.c

395

fs_info->sectorsize *

fs/btrfs/free-space-tree.c

398

data_size = free_space_bitmap_size(fs_info,

fs/btrfs/free-space-tree.c

435

nrbits = block_group->length >> fs_info->sectorsize_bits;

fs/btrfs/free-space-tree.c

44

btrfs_warn(cache->fs_info, "block group %llu length is zero",

fs/btrfs/free-space-tree.c

442

key.objectid = start + start_bit * fs_info->sectorsize;

fs/btrfs/free-space-tree.c

444

key.offset = (end_bit - start_bit) * fs_info->sectorsize;

fs/btrfs/free-space-tree.c

459

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

528

block_group->fs_info->sectorsize);

fs/btrfs/free-space-tree.c

537

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/free-space-tree.c

557

first = (*start - found_start) >> fs_info->sectorsize_bits;

fs/btrfs/free-space-tree.c

558

last = (end - found_start) >> fs_info->sectorsize_bits;

fs/btrfs/free-space-tree.c

619

u64 prev_block = start - block_group->fs_info->sectorsize;

fs/btrfs/free-space-tree.c

837

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

fs/btrfs/free-space-tree.c

847

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_last_root_drop_gen(struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1003

WRITE_ONCE(fs_info->last_root_drop_gen, gen);

fs/btrfs/fs.h

1006

static inline u64 btrfs_get_last_root_drop_gen(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1008

return READ_ONCE(fs_info->last_root_drop_gen);

fs/btrfs/fs.h

1016

const struct btrfs_fs_info *fs_info, u64 csum_bytes)

fs/btrfs/fs.h

1018

const u64 num_csums = csum_bytes >> fs_info->sectorsize_bits;

fs/btrfs/fs.h

1020

return DIV_ROUND_UP_ULL(num_csums, fs_info->csums_per_leaf);

fs/btrfs/fs.h

1027

static inline u64 btrfs_calc_insert_metadata_size(const struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1030

return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;

fs/btrfs/fs.h

1037

static inline u64 btrfs_calc_metadata_size(const struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1040

return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;

fs/btrfs/fs.h

1043

#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r->fs_info) >> 4) - \

fs/btrfs/fs.h

1046

#define BTRFS_BYTES_TO_BLKS(fs_info, bytes) ((bytes) >> (fs_info)->sectorsize_bits)

fs/btrfs/fs.h

1048

static inline bool btrfs_is_zoned(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1050

return IS_ENABLED(CONFIG_BLK_DEV_ZONED) && fs_info->zone_size > 0;

fs/btrfs/fs.h

1056

static inline u32 count_max_extents(const struct btrfs_fs_info *fs_info, u64 size)

fs/btrfs/fs.h

1059

if (!fs_info)

fs/btrfs/fs.h

1063

return div_u64(size + fs_info->max_extent_size - 1, fs_info->max_extent_size);

fs/btrfs/fs.h

1066

static inline unsigned int btrfs_blocks_per_folio(const struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1069

return folio_size(folio) >> fs_info->sectorsize_bits;

fs/btrfs/fs.h

1073

bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1075

bool btrfs_exclop_start_try_lock(struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1077

void btrfs_exclop_start_unlock(struct btrfs_fs_info *fs_info);

fs/btrfs/fs.h

1078

void btrfs_exclop_finish(struct btrfs_fs_info *fs_info);

fs/btrfs/fs.h

1079

void btrfs_exclop_balance(struct btrfs_fs_info *fs_info,

fs/btrfs/fs.h

1108

void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,

fs/btrfs/fs.h

1110

void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,

fs/btrfs/fs.h

1112

void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,

fs/btrfs/fs.h

1114

void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,

fs/btrfs/fs.h

1117

#define __btrfs_fs_incompat(fs_info, flags) \

fs/btrfs/fs.h

1118

(!!(btrfs_super_incompat_flags((fs_info)->super_copy) & (flags)))

fs/btrfs/fs.h

1120

#define __btrfs_fs_compat_ro(fs_info, flags) \

fs/btrfs/fs.h

1121

(!!(btrfs_super_compat_ro_flags((fs_info)->super_copy) & (flags)))

fs/btrfs/fs.h

1129

#define btrfs_fs_incompat(fs_info, opt) \

fs/btrfs/fs.h

1130

__btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt)

fs/btrfs/fs.h

1138

#define btrfs_fs_compat_ro(fs_info, opt) \

fs/btrfs/fs.h

1139

__btrfs_fs_compat_ro((fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)

fs/btrfs/fs.h

1144

#define btrfs_test_opt(fs_info, opt) ((fs_info)->mount_opt & \

fs/btrfs/fs.h

1147

static inline bool btrfs_fs_closing(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1149

return unlikely(test_bit(BTRFS_FS_CLOSING_START, &fs_info->flags));

fs/btrfs/fs.h

1152

static inline bool btrfs_fs_closing_done(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1154

if (btrfs_fs_closing(fs_info) && test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags))

fs/btrfs/fs.h

1168

static inline int btrfs_need_cleaner_sleep(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1170

return test_bit(BTRFS_FS_STATE_RO, &fs_info->fs_state) ||

fs/btrfs/fs.h

1171

btrfs_fs_closing(fs_info);

fs/btrfs/fs.h

1174

static inline void btrfs_wake_unfinished_drop(struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1176

clear_and_wake_up_bit(BTRFS_FS_UNFINISHED_DROPS, &fs_info->flags);

fs/btrfs/fs.h

1179

#define BTRFS_FS_ERROR(fs_info) (READ_ONCE((fs_info)->fs_error))

fs/btrfs/fs.h

1181

#define BTRFS_FS_LOG_CLEANUP_ERROR(fs_info) \

fs/btrfs/fs.h

1183

&(fs_info)->fs_state)))

fs/btrfs/fs.h

1185

static inline bool btrfs_is_shutdown(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1187

return unlikely(test_bit(BTRFS_FS_STATE_EMERGENCY_SHUTDOWN, &fs_info->fs_state));

fs/btrfs/fs.h

1190

static inline void btrfs_force_shutdown(struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1201

WRITE_ONCE(fs_info->fs_error, -EIO);

fs/btrfs/fs.h

1202

if (!test_and_set_bit(BTRFS_FS_STATE_EMERGENCY_SHUTDOWN, &fs_info->fs_state))

fs/btrfs/fs.h

1203

btrfs_crit(fs_info, "emergency shutdown");

fs/btrfs/fs.h

1218

static inline bool btrfs_is_testing(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

1220

return unlikely(test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state));

fs/btrfs/fs.h

1229

static inline bool btrfs_is_testing(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

964

#define folio_to_fs_info(_folio) (folio_to_inode(_folio)->root->fs_info)

fs/btrfs/fs.h

967

struct inode *: (_inode)))->root->fs_info)

fs/btrfs/fs.h

975

static inline unsigned int btrfs_min_folio_size(struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

977

return 1U << (PAGE_SHIFT + fs_info->block_min_order);

fs/btrfs/fs.h

980

static inline u64 btrfs_get_fs_generation(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

982

return READ_ONCE(fs_info->generation);

fs/btrfs/fs.h

985

static inline void btrfs_set_fs_generation(struct btrfs_fs_info *fs_info, u64 gen)

fs/btrfs/fs.h

987

WRITE_ONCE(fs_info->generation, gen);

fs/btrfs/fs.h

990

static inline u64 btrfs_get_last_trans_committed(const struct btrfs_fs_info *fs_info)

fs/btrfs/fs.h

992

return READ_ONCE(fs_info->last_trans_committed);

fs/btrfs/fs.h

995

static inline void btrfs_set_last_trans_committed(struct btrfs_fs_info *fs_info, u64 gen)

fs/btrfs/fs.h

997

WRITE_ONCE(fs_info->last_trans_committed, gen);

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

10090

btrfs_dec_block_group_reservations(fs_info, ins.objectid);

fs/btrfs/inode.c

10104

btrfs_dec_block_group_reservations(fs_info, ins.objectid);

fs/btrfs/inode.c

10105

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

fs/btrfs/inode.c

10139

struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;

fs/btrfs/inode.c

10152

spin_lock(&fs_info->swapfile_pins_lock);

fs/btrfs/inode.c

10153

p = &fs_info->swapfile_pins.rb_node;

fs/btrfs/inode.c

10166

spin_unlock(&fs_info->swapfile_pins_lock);

fs/btrfs/inode.c

10172

rb_insert_color(&sp->node, &fs_info->swapfile_pins);

fs/btrfs/inode.c

10173

spin_unlock(&fs_info->swapfile_pins_lock);

fs/btrfs/inode.c

10180

struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;

fs/btrfs/inode.c

10184

spin_lock(&fs_info->swapfile_pins_lock);

fs/btrfs/inode.c

10185

node = rb_first(&fs_info->swapfile_pins);

fs/btrfs/inode.c

10190

rb_erase(&sp->node, &fs_info->swapfile_pins);

fs/btrfs/inode.c

10200

spin_unlock(&fs_info->swapfile_pins_lock);

fs/btrfs/inode.c

10267

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

10303

btrfs_warn(fs_info, "swapfile must not be compressed");

fs/btrfs/inode.c

10308

btrfs_warn(fs_info, "swapfile must not be copy-on-write");

fs/btrfs/inode.c

10313

btrfs_warn(fs_info, "swapfile must not be checksummed");

fs/btrfs/inode.c

10334

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_SWAP_ACTIVATE)) {

fs/btrfs/inode.c

10335

btrfs_warn(fs_info,

fs/btrfs/inode.c

10349

btrfs_exclop_finish(fs_info);

fs/btrfs/inode.c

10350

btrfs_warn(fs_info,

fs/btrfs/inode.c

10370

btrfs_exclop_finish(fs_info);

fs/btrfs/inode.c

10371

btrfs_warn(fs_info,

fs/btrfs/inode.c

10380

isize = ALIGN_DOWN(inode->i_size, fs_info->sectorsize);

fs/btrfs/inode.c

10407

btrfs_warn(fs_info, "swapfile must not have holes");

fs/btrfs/inode.c

10423

btrfs_warn(fs_info, "swapfile must not be inline");

fs/btrfs/inode.c

10429

btrfs_warn(fs_info, "swapfile must not be compressed");

fs/btrfs/inode.c

10436

btrfs_warn(fs_info, "swapfile must not have holes");

fs/btrfs/inode.c

10466

btrfs_warn(fs_info,

fs/btrfs/inode.c

10472

map = btrfs_get_chunk_map(fs_info, logical_block_start, len);

fs/btrfs/inode.c

10479

btrfs_warn(fs_info,

fs/btrfs/inode.c

10493

btrfs_warn(fs_info, "swapfile must be on one device");

fs/btrfs/inode.c

10503

bg = btrfs_lookup_block_group(fs_info, logical_block_start);

fs/btrfs/inode.c

10505

btrfs_warn(fs_info,

fs/btrfs/inode.c

10512

btrfs_warn(fs_info,

fs/btrfs/inode.c

10515

atomic_read(&fs_info->scrubs_running) ?

fs/btrfs/inode.c

10567

btrfs_exclop_finish(fs_info);

fs/btrfs/inode.c

10640

btrfs_err(root->fs_info,

fs/btrfs/inode.c

1076

total_in = round_up(total_in, fs_info->sectorsize);

fs/btrfs/inode.c

1095

if (!btrfs_test_opt(fs_info, FORCE_COMPRESS) && !inode->prop_compress)

fs/btrfs/inode.c

1124

btrfs_folio_end_lock(inode->root->fs_info, locked_folio,

fs/btrfs/inode.c

1126

btrfs_err_rl(inode->root->fs_info,

fs/btrfs/inode.c

1140

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

1217

btrfs_dec_block_group_reservations(fs_info, ins.objectid);

fs/btrfs/inode.c

1234

btrfs_dec_block_group_reservations(fs_info, ins.objectid);

fs/btrfs/inode.c

1235

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

fs/btrfs/inode.c

1248

btrfs_debug(fs_info,

fs/btrfs/inode.c

131

struct btrfs_fs_info *fs_info = warn->fs_info;

fs/btrfs/inode.c

1312

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

1376

btrfs_dec_block_group_reservations(fs_info, ins->objectid);

fs/btrfs/inode.c

141

local_root = btrfs_get_fs_root(fs_info, root, true);

fs/btrfs/inode.c

1417

btrfs_dec_block_group_reservations(fs_info, ins->objectid);

fs/btrfs/inode.c

1418

btrfs_free_reserved_extent(fs_info, ins->objectid, ins->offset, true);

fs/btrfs/inode.c

1460

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

1466

u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

1473

if (btrfs_is_shutdown(fs_info)) {

fs/btrfs/inode.c

1485

ASSERT(num_bytes <= btrfs_super_total_bytes(fs_info->super_copy));

fs/btrfs/inode.c

1534

min_alloc_size = fs_info->sectorsize;

fs/btrfs/inode.c

1553

ASSERT(btrfs_is_zoned(fs_info));

fs/btrfs/inode.c

1555

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

fs/btrfs/inode.c

1641

btrfs_err(fs_info,

fs/btrfs/inode.c

1661

struct btrfs_fs_info *fs_info = btrfs_work_owner(work);

fs/btrfs/inode.c

1690

if (atomic_sub_return(nr_pages, &fs_info->async_delalloc_pages) <

fs/btrfs/inode.c

1692

cond_wake_up_nomb(&fs_info->async_submit_wait);

fs/btrfs/inode.c

1699

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

fs/btrfs/inode.c

175

btrfs_warn(fs_info,

fs/btrfs/inode.c

1775

atomic_add(nr_pages, &fs_info->async_delalloc_pages);

fs/btrfs/inode.c

1777

btrfs_queue_work(fs_info->delalloc_workers, &async_chunk[i].work);

fs/btrfs/inode.c

1859

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

fs/btrfs/inode.c

1860

struct btrfs_space_info *sinfo = fs_info->data_sinfo;

fs/btrfs/inode.c

191

btrfs_warn(fs_info,

fs/btrfs/inode.c

194

fs_info->sectorsize, nlink,

fs/btrfs/inode.c

2014

csum_root = btrfs_csum_root(root->fs_info, io_start);

fs/btrfs/inode.c

2016

btrfs_err(root->fs_info,

fs/btrfs/inode.c

202

btrfs_warn(fs_info,

fs/btrfs/inode.c

2096

btrfs_err(inode->root->fs_info,

fs/btrfs/inode.c

2114

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

fs/btrfs/inode.c

2144

ASSERT(!btrfs_is_zoned(fs_info) || btrfs_is_data_reloc_root(root));

fs/btrfs/inode.c

2146

if (btrfs_is_shutdown(fs_info)) {

fs/btrfs/inode.c

219

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

fs/btrfs/inode.c

224

const u32 csum_size = fs_info->csum_size;

fs/btrfs/inode.c

2262

nocow_bg = btrfs_inc_nocow_writers(fs_info,

fs/btrfs/inode.c

230

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/inode.c

231

logical = btrfs_get_reloc_bg_bytenr(fs_info);

fs/btrfs/inode.c

232

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/inode.c

235

btrfs_warn_rl(fs_info, "has data reloc tree but no running relocation");

fs/btrfs/inode.c

236

btrfs_warn_rl(fs_info,

fs/btrfs/inode.c

2419

btrfs_err(fs_info,

fs/btrfs/inode.c

2445

const bool zoned = btrfs_is_zoned(inode->root->fs_info);

fs/btrfs/inode.c

246

btrfs_warn_rl(fs_info,

fs/btrfs/inode.c

2471

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

fs/btrfs/inode.c

2481

if (size > fs_info->max_extent_size) {

fs/btrfs/inode.c

2490

num_extents = count_max_extents(fs_info, new_size);

fs/btrfs/inode.c

2492

num_extents += count_max_extents(fs_info, new_size);

fs/btrfs/inode.c

2493

if (count_max_extents(fs_info, size) >= num_extents)

fs/btrfs/inode.c

2510

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

fs/btrfs/inode.c

2526

if (new_size <= fs_info->max_extent_size) {

fs/btrfs/inode.c

254

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

fs/btrfs/inode.c

2552

num_extents = count_max_extents(fs_info, old_size);

fs/btrfs/inode.c

2554

num_extents += count_max_extents(fs_info, old_size);

fs/btrfs/inode.c

2555

if (count_max_extents(fs_info, new_size) >= num_extents)

fs/btrfs/inode.c

256

btrfs_err_rl(fs_info, "failed to lookup extent item for logical %llu: %d",

fs/btrfs/inode.c

2566

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

2573

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

2575

list_add_tail(&root->delalloc_root, &fs_info->delalloc_roots);

fs/btrfs/inode.c

2576

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

2584

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

2599

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

2602

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

2614

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

fs/btrfs/inode.c

2628

u32 num_extents = count_max_extents(fs_info, len);

fs/btrfs/inode.c

2635

if (btrfs_is_testing(fs_info))

fs/btrfs/inode.c

2638

percpu_counter_add_batch(&fs_info->delalloc_bytes, len,

fs/btrfs/inode.c

2639

fs_info->delalloc_batch);

fs/btrfs/inode.c

2672

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

fs/btrfs/inode.c

2674

u32 num_extents = count_max_extents(fs_info, len);

fs/btrfs/inode.c

2703

root != fs_info->tree_root)

fs/btrfs/inode.c

2707

if (btrfs_is_testing(fs_info))

fs/btrfs/inode.c

2716

percpu_counter_add_batch(&fs_info->delalloc_bytes, -len,

fs/btrfs/inode.c

2717

fs_info->delalloc_batch);

fs/btrfs/inode.c

273

btrfs_warn_rl(fs_info,

fs/btrfs/inode.c

2760

csum_root = btrfs_csum_root(trans->fs_info,

fs/btrfs/inode.c

2763

btrfs_err(trans->fs_info,

fs/btrfs/inode.c

281

btrfs_warn_rl(fs_info,

fs/btrfs/inode.c

2860

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

fs/btrfs/inode.c

2963

btrfs_folio_clear_checked(fs_info, folio, page_start, PAGE_SIZE);

fs/btrfs/inode.c

299

ctx.fs_info = fs_info;

fs/btrfs/inode.c

2990

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/inode.c

3004

btrfs_err_rl(fs_info,

fs/btrfs/inode.c

3034

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

fs/btrfs/inode.c

3039

btrfs_queue_work(fs_info->fixup_workers, &fixup->work);

fs/btrfs/inode.c

304

reloc_warn.fs_info = fs_info;

fs/btrfs/inode.c

3051

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

fs/btrfs/inode.c

3135

static void btrfs_release_delalloc_bytes(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

3140

cache = btrfs_lookup_block_group(fs_info, start);

fs/btrfs/inode.c

315

const u32 csum_size = root->fs_info->csum_size;

fs/btrfs/inode.c

3195

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

3219

btrfs_lockdep_acquire(fs_info, btrfs_ordered_extent);

fs/btrfs/inode.c

3226

ret = btrfs_zone_finish_endio(fs_info, ordered_extent->disk_bytenr,

fs/btrfs/inode.c

324

btrfs_warn_rl(root->fs_info,

fs/btrfs/inode.c

3298

btrfs_zoned_release_data_reloc_bg(fs_info, ordered_extent->disk_bytenr,

fs/btrfs/inode.c

3305

BUG_ON(root == fs_info->tree_root);

fs/btrfs/inode.c

3312

btrfs_release_delalloc_bytes(fs_info,

fs/btrfs/inode.c

332

btrfs_warn_rl(root->fs_info,

fs/btrfs/inode.c

3408

if (ret && btrfs_test_opt(fs_info, DISCARD_SYNC))

fs/btrfs/inode.c

3409

btrfs_discard_extent(fs_info,

fs/btrfs/inode.c

3413

btrfs_free_reserved_extent(fs_info,

fs/btrfs/inode.c

3420

btrfs_qgroup_free_refroot(fs_info, btrfs_root_id(inode->root),

fs/btrfs/inode.c

3442

if (btrfs_is_zoned(ordered->inode->root->fs_info) &&

fs/btrfs/inode.c

3455

void btrfs_calculate_block_csum_folio(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

3459

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

3479

return btrfs_calculate_block_csum_pages(fs_info, paddrs, dest);

fs/btrfs/inode.c

3488

void btrfs_calculate_block_csum_pages(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

3491

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

3496

btrfs_csum_init(&csum, fs_info->csum_type);

fs/btrfs/inode.c

3515

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

fs/btrfs/inode.c

3518

btrfs_calculate_block_csum_folio(fs_info, paddr, csum);

fs/btrfs/inode.c

3519

if (unlikely(memcmp(csum, csum_expected, fs_info->csum_size) != 0))

fs/btrfs/inode.c

3542

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

fs/btrfs/inode.c

3543

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

3563

csum_expected = bbio->csum + (bio_offset >> fs_info->sectorsize_bits) *

fs/btrfs/inode.c

3564

fs_info->csum_size;

fs/btrfs/inode.c

3565

btrfs_calculate_block_csum_pages(fs_info, paddrs, csum);

fs/btrfs/inode.c

3566

if (unlikely(memcmp(csum, csum_expected, fs_info->csum_size) != 0))

fs/btrfs/inode.c

3592

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

fs/btrfs/inode.c

3598

WARN_ON_ONCE(test_bit(BTRFS_FS_STATE_NO_DELAYED_IPUT, &fs_info->fs_state));

fs/btrfs/inode.c

3599

atomic_inc(&fs_info->nr_delayed_iputs);

fs/btrfs/inode.c

3605

spin_lock_irqsave(&fs_info->delayed_iput_lock, flags);

fs/btrfs/inode.c

3607

list_add_tail(&inode->delayed_iput, &fs_info->delayed_iputs);

fs/btrfs/inode.c

3608

spin_unlock_irqrestore(&fs_info->delayed_iput_lock, flags);

fs/btrfs/inode.c

3609

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

fs/btrfs/inode.c

3610

wake_up_process(fs_info->cleaner_kthread);

fs/btrfs/inode.c

3613

static void run_delayed_iput_locked(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

3617

spin_unlock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3619

if (atomic_dec_and_test(&fs_info->nr_delayed_iputs))

fs/btrfs/inode.c

3620

wake_up(&fs_info->delayed_iputs_wait);

fs/btrfs/inode.c

3621

spin_lock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3624

static void btrfs_run_delayed_iput(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

3628

spin_lock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3630

run_delayed_iput_locked(fs_info, inode);

fs/btrfs/inode.c

3631

spin_unlock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3635

void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info)

fs/btrfs/inode.c

3643

spin_lock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3644

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

fs/btrfs/inode.c

3647

inode = list_first_entry(&fs_info->delayed_iputs,

fs/btrfs/inode.c

3649

run_delayed_iput_locked(fs_info, inode);

fs/btrfs/inode.c

3651

spin_unlock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3653

spin_lock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3656

spin_unlock_irq(&fs_info->delayed_iput_lock);

fs/btrfs/inode.c

3671

int btrfs_wait_on_delayed_iputs(struct btrfs_fs_info *fs_info)

fs/btrfs/inode.c

3673

int ret = wait_event_killable(fs_info->delayed_iputs_wait,

fs/btrfs/inode.c

3674

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

fs/btrfs/inode.c

3714

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

3782

btrfs_err(fs_info,

fs/btrfs/inode.c

3784

ret = BTRFS_FS_ERROR(fs_info) ?: -EINVAL;

fs/btrfs/inode.c

3801

if (!inode && root == fs_info->tree_root) {

fs/btrfs/inode.c

3821

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/inode.c

3822

dead_root = radix_tree_lookup(&fs_info->fs_roots_radix,

fs/btrfs/inode.c

3826

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/inode.c

3875

btrfs_debug(fs_info, "auto deleting %Lu",

fs/btrfs/inode.c

3900

btrfs_debug(fs_info, "unlinked %d orphans", nr_unlink);

fs/btrfs/inode.c

3904

btrfs_err(fs_info, "could not do orphan cleanup %d", ret);

fs/btrfs/inode.c

3988

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

fs/btrfs/inode.c

3992

if (btrfs_fs_incompat(fs_info, NO_HOLES))

fs/btrfs/inode.c

4003

btrfs_extent_io_tree_init(fs_info, inode->file_extent_tree,

fs/btrfs/inode.c

4050

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

4133

if (inode->last_trans == btrfs_get_fs_generation(fs_info))

fs/btrfs/inode.c

4205

btrfs_err(fs_info,

fs/btrfs/inode.c

422

btrfs_folio_clamp_clear_ordered(inode->root->fs_info, folio,

fs/btrfs/inode.c

4222

round_up(i_size_read(vfs_inode), fs_info->sectorsize));

fs/btrfs/inode.c

4348

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

4360

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

fs/btrfs/inode.c

4393

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

fs/btrfs/inode.c

4412

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

4458

btrfs_crit(fs_info,

fs/btrfs/inode.c

4494

btrfs_run_delayed_iput(fs_info, inode);

fs/btrfs/inode.c

4570

btrfs_btree_balance_dirty(BTRFS_I(dir)->root->fs_info);

fs/btrfs/inode.c

4684

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

469

const u32 sectorsize = trans->fs_info->sectorsize;

fs/btrfs/inode.c

4697

dir_id = btrfs_super_root_dir(fs_info->super_copy);

fs/btrfs/inode.c

4698

di = btrfs_lookup_dir_item(NULL, fs_info->tree_root, path,

fs/btrfs/inode.c

4704

btrfs_err(fs_info,

fs/btrfs/inode.c

4716

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

fs/btrfs/inode.c

4741

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

4745

if (!BTRFS_FS_ERROR(fs_info))

fs/btrfs/inode.c

4767

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

4776

down_write(&fs_info->subvol_sem);

fs/btrfs/inode.c

4786

btrfs_warn(fs_info,

fs/btrfs/inode.c

4794

btrfs_warn(fs_info,

fs/btrfs/inode.c

4851

fs_info->tree_root,

fs/btrfs/inode.c

4884

btrfs_block_rsv_release(fs_info, &block_rsv, (u64)-1, NULL);

fs/btrfs/inode.c

4896

up_write(&fs_info->subvol_sem);

fs/btrfs/inode.c

4910

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

fs/btrfs/inode.c

4918

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

fs/btrfs/inode.c

4919

btrfs_err(fs_info,

fs/btrfs/inode.c

4971

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

5052

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

fs/btrfs/inode.c

5059

u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

5214

btrfs_folio_clear_checked(fs_info, folio, block_start,

fs/btrfs/inode.c

5216

btrfs_folio_set_dirty(fs_info, folio, block_start,

fs/btrfs/inode.c

5246

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

5257

if (btrfs_fs_incompat(fs_info, NO_HOLES))

fs/btrfs/inode.c

5300

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

5304

u64 hole_start = ALIGN(oldsize, fs_info->sectorsize);

fs/btrfs/inode.c

5305

u64 block_end = ALIGN(size, fs_info->sectorsize);

fs/btrfs/inode.c

5334

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

fs/btrfs/inode.c

5363

hole_em->generation = btrfs_get_fs_generation(fs_info);

fs/btrfs/inode.c

5436

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/inode.c

5438

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/inode.c

5440

ALIGN(newsize, fs_info->sectorsize),

fs/btrfs/inode.c

547

ALIGN(size, root->fs_info->sectorsize));

fs/btrfs/inode.c

5592

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

5594

u64 delayed_refs_extra = btrfs_calc_delayed_ref_bytes(fs_info, 1);

fs/btrfs/inode.c

5611

ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size + delayed_refs_extra,

fs/btrfs/inode.c

5614

ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size,

fs/btrfs/inode.c

5617

btrfs_warn(fs_info,

fs/btrfs/inode.c

5629

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/inode.c

5639

struct btrfs_fs_info *fs_info;

fs/btrfs/inode.c

5650

fs_info = inode_to_fs_info(inode);

fs/btrfs/inode.c

5662

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

fs/btrfs/inode.c

5687

btrfs_init_metadata_block_rsv(fs_info, &rsv, BTRFS_BLOCK_RSV_TEMP);

fs/btrfs/inode.c

5688

rsv.size = btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/inode.c

5708

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/inode.c

5715

btrfs_btree_balance_dirty_nodelay(fs_info);

fs/btrfs/inode.c

572

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

fs/btrfs/inode.c

5735

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/inode.c

5740

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

fs/btrfs/inode.c

5794

btrfs_warn(root->fs_info,

fs/btrfs/inode.c

5811

static int fixup_tree_root_location(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

5841

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

fs/btrfs/inode.c

5861

new_root = btrfs_get_fs_root(fs_info, location->objectid, true);

fs/btrfs/inode.c

5918

if (args->root && args->root == args->root->fs_info->tree_root &&

fs/btrfs/inode.c

592

if (size > fs_info->sectorsize)

fs/btrfs/inode.c

5942

inode = iget5_locked_rcu(root->fs_info->sb, hashval, btrfs_find_actor,

fs/btrfs/inode.c

596

if (data_len >= fs_info->sectorsize)

fs/btrfs/inode.c

600

if (data_len > BTRFS_MAX_INLINE_DATA_SIZE(fs_info))

fs/btrfs/inode.c

604

if (data_len > fs_info->max_inline)

fs/btrfs/inode.c

6064

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/inode.c

6086

btrfs_crit(fs_info,

fs/btrfs/inode.c

6096

ret = fixup_tree_root_location(fs_info, BTRFS_I(dir), dentry,

fs/btrfs/inode.c

6110

down_read(&fs_info->cleanup_work_sem);

fs/btrfs/inode.c

6113

up_read(&fs_info->cleanup_work_sem);

fs/btrfs/inode.c

6185

btrfs_err(root->fs_info,

fs/btrfs/inode.c

634

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

6436

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

6459

btrfs_balance_delayed_items(fs_info);

fs/btrfs/inode.c

656

drop_args.end = fs_info->sectorsize;

fs/btrfs/inode.c

6616

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/inode.c

6707

if (btrfs_test_opt(fs_info, NODATASUM))

fs/btrfs/inode.c

6709

if (btrfs_test_opt(fs_info, NODATACOW))

fs/btrfs/inode.c

6825

btrfs_err(fs_info,

fs/btrfs/inode.c

6966

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/inode.c

699

btrfs_qgroup_free_data(inode, NULL, 0, fs_info->sectorsize, NULL);

fs/btrfs/inode.c

6995

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

7039

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/inode.c

7111

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

7135

const u32 blocksize = leaf->fs_info->sectorsize;

fs/btrfs/inode.c

7172

const u32 blocksize = path->nodes[0]->fs_info->sectorsize;

fs/btrfs/inode.c

7218

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

fs/btrfs/inode.c

7306

btrfs_crit(fs_info,

fs/btrfs/inode.c

7367

ASSERT(em->len == fs_info->sectorsize);

fs/btrfs/inode.c

7382

btrfs_err(fs_info,

fs/btrfs/inode.c

7404

static bool btrfs_extent_readonly(struct btrfs_fs_info *fs_info, u64 bytenr)

fs/btrfs/inode.c

7409

block_group = btrfs_lookup_block_group(fs_info, bytenr);

fs/btrfs/inode.c

7440

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

7500

if (btrfs_extent_readonly(fs_info,

fs/btrfs/inode.c

7510

root->fs_info->sectorsize) - 1;

fs/btrfs/inode.c

7604

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/inode.c

7607

if (!btrfs_is_subpage(fs_info, folio))

fs/btrfs/inode.c

7676

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

fs/btrfs/inode.c

7754

if (!btrfs_folio_test_ordered(fs_info, folio, cur, range_len)) {

fs/btrfs/inode.c

7763

btrfs_folio_clear_ordered(fs_info, folio, cur, range_len);

fs/btrfs/inode.c

7832

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

fs/btrfs/inode.c

7848

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

7852

const u64 min_size = btrfs_calc_metadata_size(fs_info, 1);

fs/btrfs/inode.c

7853

const u64 lock_start = round_down(inode->vfs_inode.i_size, fs_info->sectorsize);

fs/btrfs/inode.c

7854

const u64 i_size_up = round_up(inode->vfs_inode.i_size, fs_info->sectorsize);

fs/btrfs/inode.c

7893

btrfs_init_metadata_block_rsv(fs_info, &rsv, BTRFS_BLOCK_RSV_TEMP);

fs/btrfs/inode.c

7908

ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, &rsv,

fs/btrfs/inode.c

7940

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/inode.c

7949

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

7958

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

fs/btrfs/inode.c

7959

ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv,

fs/btrfs/inode.c

7980

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

7997

trans->block_rsv = &fs_info->trans_block_rsv;

fs/btrfs/inode.c

8005

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

8008

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

fs/btrfs/inode.c

802

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

fs/btrfs/inode.c

8050

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/inode.c

8084

btrfs_init_metadata_block_rsv(fs_info, &ei->block_rsv,

fs/btrfs/inode.c

8099

btrfs_extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO);

fs/btrfs/inode.c

814

if (start != 0 && end + 1 - start <= fs_info->sectorsize)

fs/btrfs/inode.c

8169

btrfs_err(root->fs_info,

fs/btrfs/inode.c

8174

btrfs_lockdep_acquire(root->fs_info, btrfs_ordered_extent);

fs/btrfs/inode.c

823

if (btrfs_test_opt(fs_info, FORCE_COMPRESS))

fs/btrfs/inode.c

828

if (btrfs_test_opt(fs_info, COMPRESS) ||

fs/btrfs/inode.c

8281

struct btrfs_fs_info *fs_info = inode_to_fs_info(old_dir);

fs/btrfs/inode.c

8327

down_read(&fs_info->subvol_sem);

fs/btrfs/inode.c

8539

up_read(&fs_info->subvol_sem);

fs/btrfs/inode.c

8566

struct btrfs_fs_info *fs_info = inode_to_fs_info(old_dir);

fs/btrfs/inode.c

857

btrfs_folio_clamp_clear_dirty(inode->root->fs_info, folio, start,

fs/btrfs/inode.c

8649

down_read(&fs_info->subvol_sem);

fs/btrfs/inode.c

877

struct btrfs_fs_info *fs_info = cb_to_fs_info(cb);

fs/btrfs/inode.c

878

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/inode.c

8829

up_read(&fs_info->subvol_sem);

fs/btrfs/inode.c

8857

btrfs_btree_balance_dirty(BTRFS_I(new_dir)->root->fs_info);

fs/btrfs/inode.c

8946

btrfs_queue_work(root->fs_info->flush_workers,

fs/btrfs/inode.c

8979

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

8981

if (BTRFS_FS_ERROR(fs_info))

fs/btrfs/inode.c

8986

int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, long nr,

fs/btrfs/inode.c

8994

if (BTRFS_FS_ERROR(fs_info))

fs/btrfs/inode.c

8997

mutex_lock(&fs_info->delalloc_root_mutex);

fs/btrfs/inode.c

8998

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

8999

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

fs/btrfs/inode.c

9006

&fs_info->delalloc_roots);

fs/btrfs/inode.c

9007

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

9014

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

9016

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

9021

spin_lock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

9022

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

fs/btrfs/inode.c

9023

spin_unlock(&fs_info->delalloc_root_lock);

fs/btrfs/inode.c

9025

mutex_unlock(&fs_info->delalloc_root_mutex);

fs/btrfs/inode.c

9032

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/inode.c

9055

if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(fs_info) ||

fs/btrfs/inode.c

9056

name_len >= fs_info->sectorsize)

fs/btrfs/inode.c

9125

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

9205

btrfs_qgroup_free_refroot(inode->root->fs_info,

fs/btrfs/inode.c

9216

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/inode.c

9264

btrfs_dec_block_group_reservations(fs_info, ins.objectid);

fs/btrfs/inode.c

9267

btrfs_free_reserved_extent(fs_info, ins.objectid,

fs/btrfs/inode.c

937

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

fs/btrfs/inode.c

9372

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/inode.c

940

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/inode.c

941

u64 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

9421

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/inode.c

9430

int btrfs_encoded_io_compression_from_extent(struct btrfs_fs_info *fs_info,

fs/btrfs/inode.c

9443

if (fs_info->sectorsize < SZ_4K || fs_info->sectorsize > SZ_64K)

fs/btrfs/inode.c

9446

(fs_info->sectorsize_bits - 12);

fs/btrfs/inode.c

9465

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

9499

ret = btrfs_encoded_io_compression_from_extent(fs_info,

fs/btrfs/inode.c

95

struct btrfs_fs_info *fs_info;

fs/btrfs/inode.c

951

int compress_type = fs_info->compress_type;

fs/btrfs/inode.c

952

int compress_level = fs_info->compress_level;

fs/btrfs/inode.c

954

if (btrfs_is_shutdown(fs_info))

fs/btrfs/inode.c

9714

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

fs/btrfs/inode.c

9734

start = ALIGN_DOWN(iocb->ki_pos, fs_info->sectorsize);

fs/btrfs/inode.c

9830

ret = btrfs_encoded_io_compression_from_extent(fs_info,

fs/btrfs/inode.c

9847

*disk_io_size = ALIGN(*disk_io_size, fs_info->sectorsize);

fs/btrfs/inode.c

9881

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/inode.c

9890

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/inode.c

9891

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/inode.c

9914

fs_info->sectorsize_bits)

fs/btrfs/inode.c

9956

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

fs/btrfs/inode.c

9965

!IS_ALIGNED(start + encoded->len, fs_info->sectorsize))

fs/btrfs/inode.c

9969

if (!IS_ALIGNED(encoded->unencoded_offset, fs_info->sectorsize))

fs/btrfs/inode.c

9972

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

fs/btrfs/inode.c

9973

ram_bytes = ALIGN(encoded->unencoded_len, fs_info->sectorsize);

fs/btrfs/inode.c

9981

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

fs/btrfs/inode.c

9989

folio = btrfs_alloc_compr_folio(fs_info);

fs/btrfs/ioctl.c

1011

btrfs_info(fs_info, "resizing devid %llu", devid);

fs/btrfs/ioctl.c

1015

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

fs/btrfs/ioctl.c

1017

btrfs_info(fs_info, "resizer unable to find device %llu",

fs/btrfs/ioctl.c

1024

btrfs_info(fs_info,

fs/btrfs/ioctl.c

1080

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

fs/btrfs/ioctl.c

1097

btrfs_info(fs_info,

fs/btrfs/ioctl.c

1102

btrfs_exclop_finish(fs_info);

fs/btrfs/ioctl.c

1150

btrfs_info(BTRFS_I(file_inode(file))->root->fs_info,

fs/btrfs/ioctl.c

1230

struct btrfs_fs_info *fs_info = inode_to_fs_info(file_inode(file));

fs/btrfs/ioctl.c

1243

ret = btrfs_qgroup_check_inherit(fs_info, inherit, vol_args->size);

fs/btrfs/ioctl.c

1264

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ioctl.c

1271

down_read(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

1274

up_read(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

1286

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

1315

down_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

1337

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

1351

ret = btrfs_update_root(trans, fs_info->tree_root,

fs/btrfs/ioctl.c

1364

up_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

1524

struct btrfs_fs_info *info = root->fs_info;

fs/btrfs/ioctl.c

1731

struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;

fs/btrfs/ioctl.c

1760

root = btrfs_get_fs_root(fs_info, treeid, true);

fs/btrfs/ioctl.c

1836

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

fs/btrfs/ioctl.c

1892

ret = btrfs_search_path_in_tree(root->fs_info,

fs/btrfs/ioctl.c

1951

struct btrfs_fs_info *fs_info;

fs/btrfs/ioctl.c

1973

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

fs/btrfs/ioctl.c

1977

root = btrfs_get_fs_root(fs_info, key.objectid, true);

fs/btrfs/ioctl.c

2015

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

fs/btrfs/ioctl.c

2020

ret = btrfs_next_leaf(fs_info->tree_root, path);

fs/btrfs/ioctl.c

2097

root = root->fs_info->tree_root;

fs/btrfs/ioctl.c

2166

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/ioctl.c

2178

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/ioctl.c

2179

btrfs_err(fs_info,

fs/btrfs/ioctl.c

221

static int check_fsflags_compatible(const struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

2219

dentry = btrfs_get_dentry(fs_info->sb,

fs/btrfs/ioctl.c

224

if (btrfs_is_zoned(fs_info) && (flags & FS_NOCOW_FL))

fs/btrfs/ioctl.c

2272

fs_info, vol_args2->subvolid);

fs/btrfs/ioctl.c

2330

if (!btrfs_test_opt(fs_info, USER_SUBVOL_RM_ALLOWED))

fs/btrfs/ioctl.c

2462

static long btrfs_ioctl_add_dev(struct btrfs_fs_info *fs_info, void __user *arg)

fs/btrfs/ioctl.c

2471

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/ioctl.c

2472

btrfs_err(fs_info, "device add not supported on extent tree v2 yet");

fs/btrfs/ioctl.c

2476

if (fs_info->fs_devices->temp_fsid) {

fs/btrfs/ioctl.c

2477

btrfs_err(fs_info,

fs/btrfs/ioctl.c

2482

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_DEV_ADD)) {

fs/btrfs/ioctl.c

2483

if (!btrfs_exclop_start_try_lock(fs_info, BTRFS_EXCLOP_DEV_ADD))

fs/btrfs/ioctl.c

2491

fs_info->exclusive_operation = BTRFS_EXCLOP_DEV_ADD;

fs/btrfs/ioctl.c

2492

btrfs_exclop_start_unlock(fs_info);

fs/btrfs/ioctl.c

2506

ret = btrfs_init_new_device(fs_info, vol_args->name);

fs/btrfs/ioctl.c

2509

btrfs_info(fs_info, "disk added %s", vol_args->name);

fs/btrfs/ioctl.c

2515

btrfs_exclop_balance(fs_info, BTRFS_EXCLOP_BALANCE_PAUSED);

fs/btrfs/ioctl.c

2517

btrfs_exclop_finish(fs_info);

fs/btrfs/ioctl.c

2525

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

2552

ret = btrfs_get_dev_args_from_path(fs_info, &args, vol_args->name);

fs/btrfs/ioctl.c

2561

ret = exclop_start_or_cancel_reloc(fs_info, BTRFS_EXCLOP_DEV_REMOVE,

fs/btrfs/ioctl.c

2567

ret = btrfs_rm_device(fs_info, &args, &bdev_file);

fs/btrfs/ioctl.c

2569

btrfs_exclop_finish(fs_info);

fs/btrfs/ioctl.c

2573

btrfs_info(fs_info, "device deleted: id %llu",

fs/btrfs/ioctl.c

2576

btrfs_info(fs_info, "device deleted: %s",

fs/btrfs/ioctl.c

2593

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

261

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ioctl.c

2613

ret = btrfs_get_dev_args_from_path(fs_info, &args, vol_args->name);

fs/btrfs/ioctl.c

2622

ret = exclop_start_or_cancel_reloc(fs_info, BTRFS_EXCLOP_DEV_REMOVE,

fs/btrfs/ioctl.c

2625

ret = btrfs_rm_device(fs_info, &args, &bdev_file);

fs/btrfs/ioctl.c

2627

btrfs_info(fs_info, "disk deleted %s", vol_args->name);

fs/btrfs/ioctl.c

2628

btrfs_exclop_finish(fs_info);

fs/btrfs/ioctl.c

2641

static long btrfs_ioctl_fs_info(const struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

2646

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/ioctl.c

2667

fi_args->nodesize = fs_info->nodesize;

fs/btrfs/ioctl.c

2668

fi_args->sectorsize = fs_info->sectorsize;

fs/btrfs/ioctl.c

2669

fi_args->clone_alignment = fs_info->sectorsize;

fs/btrfs/ioctl.c

2672

fi_args->csum_type = btrfs_super_csum_type(fs_info->super_copy);

fs/btrfs/ioctl.c

2673

fi_args->csum_size = btrfs_super_csum_size(fs_info->super_copy);

fs/btrfs/ioctl.c

2678

fi_args->generation = btrfs_get_fs_generation(fs_info);

fs/btrfs/ioctl.c

2695

static long btrfs_ioctl_dev_info(const struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

2712

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

fs/btrfs/ioctl.c

2740

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

2767

new_root = btrfs_get_fs_root(fs_info, objectid, true);

fs/btrfs/ioctl.c

2789

dir_id = btrfs_super_root_dir(fs_info->super_copy);

fs/btrfs/ioctl.c

2790

di = btrfs_lookup_dir_item(trans, fs_info->tree_root, path,

fs/btrfs/ioctl.c

2795

btrfs_err(fs_info,

fs/btrfs/ioctl.c

280

ret = check_fsflags_compatible(fs_info, fsflags);

fs/btrfs/ioctl.c

2805

btrfs_set_fs_incompat(fs_info, DEFAULT_SUBVOL);

fs/btrfs/ioctl.c

2830

static long btrfs_ioctl_space_info(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

2860

list_for_each_entry(tmp, &fs_info->space_info, list) {

fs/btrfs/ioctl.c

2913

list_for_each_entry(tmp, &fs_info->space_info, list) {

fs/btrfs/ioctl.c

2942

struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;

fs/btrfs/ioctl.c

2985

transid = btrfs_get_last_trans_committed(root->fs_info);

fs/btrfs/ioctl.c

2997

static noinline long btrfs_ioctl_wait_sync(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3007

return btrfs_wait_for_commit(fs_info, transid);

fs/btrfs/ioctl.c

3012

struct btrfs_fs_info *fs_info = inode_to_fs_info(file_inode(file));

fs/btrfs/ioctl.c

3019

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/ioctl.c

3020

btrfs_err(fs_info, "scrub: extent tree v2 not yet supported");

fs/btrfs/ioctl.c

3039

ret = btrfs_scrub_dev(fs_info, sa->devid, sa->start, sa->end,

fs/btrfs/ioctl.c

3065

static long btrfs_ioctl_scrub_cancel(struct btrfs_fs_info *fs_info)

fs/btrfs/ioctl.c

3070

return btrfs_scrub_cancel(fs_info);

fs/btrfs/ioctl.c

3073

static long btrfs_ioctl_scrub_progress(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3086

ret = btrfs_scrub_progress(fs_info, sa->devid, &sa->progress);

fs/btrfs/ioctl.c

3095

static long btrfs_ioctl_get_dev_stats(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3110

ret = btrfs_get_dev_stats(fs_info, sa);

fs/btrfs/ioctl.c

3119

static long btrfs_ioctl_dev_replace(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3128

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/ioctl.c

3129

btrfs_err(fs_info, "device replace not supported on extent tree v2 yet");

fs/btrfs/ioctl.c

3139

if (sb_rdonly(fs_info->sb)) {

fs/btrfs/ioctl.c

3143

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_DEV_REPLACE)) {

fs/btrfs/ioctl.c

3146

ret = btrfs_dev_replace_by_ioctl(fs_info, p);

fs/btrfs/ioctl.c

3147

btrfs_exclop_finish(fs_info);

fs/btrfs/ioctl.c

3151

btrfs_dev_replace_status(fs_info, p);

fs/btrfs/ioctl.c

3155

p->result = btrfs_dev_replace_cancel(fs_info);

fs/btrfs/ioctl.c

3230

static long btrfs_ioctl_logical_to_ino(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3270

ret = iterate_inodes_from_logical(loi->logical, fs_info, inodes, ignore_offset);

fs/btrfs/ioctl.c

3289

void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3292

struct btrfs_balance_control *bctl = fs_info->balance_ctl;

fs/btrfs/ioctl.c

3296

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

fs/btrfs/ioctl.c

3298

if (atomic_read(&fs_info->balance_pause_req))

fs/btrfs/ioctl.c

3300

if (atomic_read(&fs_info->balance_cancel_req))

fs/btrfs/ioctl.c

3307

spin_lock(&fs_info->balance_lock);

fs/btrfs/ioctl.c

3309

spin_unlock(&fs_info->balance_lock);

fs/btrfs/ioctl.c

3323

static int btrfs_try_lock_balance(struct btrfs_fs_info *fs_info, bool *excl_acquired)

fs/btrfs/ioctl.c

3334

if (btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE)) {

fs/btrfs/ioctl.c

3336

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3340

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3341

if (fs_info->balance_ctl) {

fs/btrfs/ioctl.c

3343

if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) {

fs/btrfs/ioctl.c

3349

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3354

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3356

if (fs_info->balance_ctl &&

fs/btrfs/ioctl.c

3357

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

fs/btrfs/ioctl.c

3369

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3373

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3381

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ioctl.c

3401

ret = btrfs_try_lock_balance(fs_info, &need_unlock);

fs/btrfs/ioctl.c

3405

lockdep_assert_held(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3408

if (!fs_info->balance_ctl) {

fs/btrfs/ioctl.c

3413

bctl = fs_info->balance_ctl;

fs/btrfs/ioctl.c

3414

spin_lock(&fs_info->balance_lock);

fs/btrfs/ioctl.c

3416

spin_unlock(&fs_info->balance_lock);

fs/btrfs/ioctl.c

3417

btrfs_exclop_balance(fs_info, BTRFS_EXCLOP_BALANCE);

fs/btrfs/ioctl.c

3427

if (fs_info->balance_ctl) {

fs/btrfs/ioctl.c

3452

ret = btrfs_balance(fs_info, bctl, bargs);

fs/btrfs/ioctl.c

3462

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3464

btrfs_exclop_finish(fs_info);

fs/btrfs/ioctl.c

3471

static long btrfs_ioctl_balance_ctl(struct btrfs_fs_info *fs_info, int cmd)

fs/btrfs/ioctl.c

3478

return btrfs_pause_balance(fs_info);

fs/btrfs/ioctl.c

3480

return btrfs_cancel_balance(fs_info);

fs/btrfs/ioctl.c

3486

static long btrfs_ioctl_balance_progress(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3495

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3496

if (!fs_info->balance_ctl) {

fs/btrfs/ioctl.c

3507

btrfs_update_ioctl_balance_args(fs_info, bargs);

fs/btrfs/ioctl.c

3512

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/ioctl.c

3519

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

3539

down_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

3540

ret = btrfs_quota_enable(fs_info, sa);

fs/btrfs/ioctl.c

3541

up_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

3568

mutex_lock(&fs_info->cleaner_mutex);

fs/btrfs/ioctl.c

3569

down_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

3570

ret = btrfs_quota_disable(fs_info);

fs/btrfs/ioctl.c

3571

up_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

3572

mutex_unlock(&fs_info->cleaner_mutex);

fs/btrfs/ioctl.c

3588

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

3599

if (!btrfs_qgroup_enabled(fs_info))

fs/btrfs/ioctl.c

361

comp = btrfs_compress_type2str(fs_info->compress_type);

fs/btrfs/ioctl.c

3639

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/ioctl.c

3641

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/ioctl.c

3643

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

3670

if (!btrfs_qgroup_enabled(root->fs_info))

fs/btrfs/ioctl.c

3733

if (!btrfs_qgroup_enabled(root->fs_info))

fs/btrfs/ioctl.c

3775

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

3782

if (!btrfs_qgroup_enabled(fs_info))

fs/btrfs/ioctl.c

3800

ret = btrfs_qgroup_rescan(fs_info);

fs/btrfs/ioctl.c

3809

static long btrfs_ioctl_quota_rescan_status(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

3817

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {

fs/btrfs/ioctl.c

3819

qsa.progress = fs_info->qgroup_rescan_progress.objectid;

fs/btrfs/ioctl.c

3828

static long btrfs_ioctl_quota_rescan_wait(struct btrfs_fs_info *fs_info)

fs/btrfs/ioctl.c

3833

return btrfs_qgroup_wait_for_completion(fs_info, true);

fs/btrfs/ioctl.c

3841

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

3856

down_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

3881

ret = btrfs_uuid_tree_check_overflow(fs_info, sa->uuid,

fs/btrfs/ioctl.c

3920

ret = btrfs_update_root(trans, fs_info->tree_root,

fs/btrfs/ioctl.c

3939

up_write(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

4019

static int btrfs_ioctl_get_fslabel(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

4026

spin_lock(&fs_info->super_lock);

fs/btrfs/ioctl.c

4027

memcpy(label, fs_info->super_copy->label, BTRFS_LABEL_SIZE);

fs/btrfs/ioctl.c

4028

spin_unlock(&fs_info->super_lock);

fs/btrfs/ioctl.c

4033

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4046

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

4048

struct btrfs_super_block *super_block = fs_info->super_copy;

fs/btrfs/ioctl.c

4060

btrfs_err(fs_info,

fs/btrfs/ioctl.c

4076

spin_lock(&fs_info->super_lock);

fs/btrfs/ioctl.c

4078

spin_unlock(&fs_info->super_lock);

fs/btrfs/ioctl.c

409

static noinline int btrfs_ioctl_fitrim(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

4105

static int btrfs_ioctl_get_features(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

4108

struct btrfs_super_block *super_block = fs_info->super_copy;

fs/btrfs/ioctl.c

4121

static int check_feature_bits(const struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

4136

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4140

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4150

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4154

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4164

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4168

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

4177

#define check_feature(fs_info, change_mask, flags, mask_base) \

fs/btrfs/ioctl.c

4178

check_feature_bits(fs_info, FEAT_##mask_base, change_mask, flags, \

fs/btrfs/ioctl.c

4186

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

4188

struct btrfs_super_block *super_block = fs_info->super_copy;

fs/btrfs/ioctl.c

4205

ret = check_feature(fs_info, flags[0].compat_flags,

fs/btrfs/ioctl.c

4210

ret = check_feature(fs_info, flags[0].compat_ro_flags,

fs/btrfs/ioctl.c

4215

ret = check_feature(fs_info, flags[0].incompat_flags,

fs/btrfs/ioctl.c

4230

spin_lock(&fs_info->super_lock);

fs/btrfs/ioctl.c

4245

spin_unlock(&fs_info->super_lock);

fs/btrfs/ioctl.c

426

if (btrfs_is_zoned(fs_info))

fs/btrfs/ioctl.c

4298

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

fs/btrfs/ioctl.c

436

if (btrfs_test_opt(fs_info, NOLOGREPLAY))

fs/btrfs/ioctl.c

4367

start = ALIGN_DOWN(kiocb.ki_pos, fs_info->sectorsize);

fs/btrfs/ioctl.c

440

list_for_each_entry_rcu(device, &fs_info->fs_devices->devices,

fs/btrfs/ioctl.c

460

if (range.len < fs_info->sectorsize)

fs/btrfs/ioctl.c

464

ret = btrfs_trim_fs(fs_info, &range);

fs/btrfs/ioctl.c

4685

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

fs/btrfs/ioctl.c

4777

start = ALIGN_DOWN(pos, fs_info->sectorsize);

fs/btrfs/ioctl.c

4978

static int btrfs_ioctl_subvol_sync(struct btrfs_fs_info *fs_info, void __user *argp)

fs/btrfs/ioctl.c

4997

spin_lock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

4998

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

fs/btrfs/ioctl.c

4999

root = list_last_entry(&fs_info->dead_roots,

fs/btrfs/ioctl.c

5004

spin_unlock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5015

spin_lock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5016

args.count = list_count_nodes(&fs_info->dead_roots);

fs/btrfs/ioctl.c

5017

spin_unlock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5022

spin_lock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5024

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

fs/btrfs/ioctl.c

5025

root = list_last_entry(&fs_info->dead_roots,

fs/btrfs/ioctl.c

503

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/ioctl.c

5031

spin_unlock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5036

spin_lock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5038

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

fs/btrfs/ioctl.c

5039

root = list_first_entry(&fs_info->dead_roots,

fs/btrfs/ioctl.c

5045

spin_unlock(&fs_info->trans_lock);

fs/btrfs/ioctl.c

5059

if (down_read_interruptible(&fs_info->subvol_sem) == -EINTR)

fs/btrfs/ioctl.c

5062

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/ioctl.c

5063

root = radix_tree_lookup(&fs_info->fs_roots_radix,

fs/btrfs/ioctl.c

5071

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/ioctl.c

5072

up_read(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

5105

static int btrfs_ioctl_shutdown(struct btrfs_fs_info *fs_info, unsigned long arg)

fs/btrfs/ioctl.c

5119

if (btrfs_is_shutdown(fs_info))

fs/btrfs/ioctl.c

5125

ret = freeze_super(fs_info->sb, FREEZE_HOLDER_KERNEL, NULL);

fs/btrfs/ioctl.c

5128

btrfs_force_shutdown(fs_info);

fs/btrfs/ioctl.c

5129

ret = thaw_super(fs_info->sb, FREEZE_HOLDER_KERNEL, NULL);

fs/btrfs/ioctl.c

5134

btrfs_force_shutdown(fs_info);

fs/btrfs/ioctl.c

5145

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/ioctl.c

5153

return btrfs_ioctl_get_fslabel(fs_info, argp);

fs/btrfs/ioctl.c

5157

return btrfs_ioctl_fitrim(fs_info, argp);

fs/btrfs/ioctl.c

5183

return btrfs_ioctl_add_dev(fs_info, argp);

fs/btrfs/ioctl.c

5189

return btrfs_ioctl_fs_info(fs_info, argp);

fs/btrfs/ioctl.c

5191

return btrfs_ioctl_dev_info(fs_info, argp);

fs/btrfs/ioctl.c

5201

return btrfs_ioctl_logical_to_ino(fs_info, argp, 1);

fs/btrfs/ioctl.c

5203

return btrfs_ioctl_logical_to_ino(fs_info, argp, 2);

fs/btrfs/ioctl.c

5205

return btrfs_ioctl_space_info(fs_info, argp);

fs/btrfs/ioctl.c

5209

ret = btrfs_start_delalloc_roots(fs_info, LONG_MAX, false);

fs/btrfs/ioctl.c

5217

wake_up_process(fs_info->cleaner_kthread);

fs/btrfs/ioctl.c

5223

return btrfs_ioctl_wait_sync(fs_info, argp);

fs/btrfs/ioctl.c

5227

return btrfs_ioctl_scrub_cancel(fs_info);

fs/btrfs/ioctl.c

5229

return btrfs_ioctl_scrub_progress(fs_info, argp);

fs/btrfs/ioctl.c

5233

return btrfs_ioctl_balance_ctl(fs_info, arg);

fs/btrfs/ioctl.c

5235

return btrfs_ioctl_balance_progress(fs_info, argp);

fs/btrfs/ioctl.c

5249

return btrfs_ioctl_get_dev_stats(fs_info, argp);

fs/btrfs/ioctl.c

5261

return btrfs_ioctl_quota_rescan_status(fs_info, argp);

fs/btrfs/ioctl.c

5263

return btrfs_ioctl_quota_rescan_wait(fs_info);

fs/btrfs/ioctl.c

5265

return btrfs_ioctl_dev_replace(fs_info, argp);

fs/btrfs/ioctl.c

5269

return btrfs_ioctl_get_features(fs_info, argp);

fs/btrfs/ioctl.c

528

ret = btrfs_get_free_objectid(fs_info->tree_root, &objectid);

fs/btrfs/ioctl.c

5295

return btrfs_ioctl_subvol_sync(fs_info, argp);

fs/btrfs/ioctl.c

5298

return btrfs_ioctl_shutdown(fs_info, arg);

fs/btrfs/ioctl.c

588

fs_info->nodesize);

fs/btrfs/ioctl.c

618

ret = btrfs_insert_root(trans, fs_info->tree_root, &key,

fs/btrfs/ioctl.c

643

new_root = btrfs_get_new_fs_root(fs_info, objectid, &anon_dev);

fs/btrfs/ioctl.c

690

btrfs_block_rsv_release(fs_info, &block_rsv, (u64)-1, NULL);

fs/btrfs/ioctl.c

708

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/ioctl.c

718

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/ioctl.c

719

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

731

btrfs_warn(fs_info,

fs/btrfs/ioctl.c

811

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

fs/btrfs/ioctl.c

836

struct btrfs_fs_info *fs_info = inode_to_fs_info(dir);

fs/btrfs/ioctl.c

857

down_read(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

870

up_read(&fs_info->subvol_sem);

fs/btrfs/ioctl.c

923

static int exclop_start_or_cancel_reloc(struct btrfs_fs_info *fs_info,

fs/btrfs/ioctl.c

928

if (!btrfs_exclop_start(fs_info, type))

fs/btrfs/ioctl.c

935

if (btrfs_exclop_start_try_lock(fs_info, type)) {

fs/btrfs/ioctl.c

941

atomic_inc(&fs_info->reloc_cancel_req);

fs/btrfs/ioctl.c

942

btrfs_exclop_start_unlock(fs_info);

fs/btrfs/ioctl.c

944

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

fs/btrfs/ioctl.c

945

wait_on_bit(&fs_info->flags, BTRFS_FS_RELOC_RUNNING,

fs/btrfs/ioctl.c

960

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ioctl.c

994

ret = exclop_start_or_cancel_reloc(fs_info, BTRFS_EXCLOP_RESIZE, cancel);

fs/btrfs/ioctl.h

24

void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info,

fs/btrfs/lzo.c

192

static int copy_compressed_data_to_bio(struct btrfs_fs_info *fs_info,

fs/btrfs/lzo.c

199

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/lzo.c

200

const u32 sectorsize_bits = fs_info->sectorsize_bits;

fs/btrfs/lzo.c

201

const u32 fsize = btrfs_min_folio_size(fs_info);

fs/btrfs/lzo.c

221

*out_folio = btrfs_alloc_compr_folio(fs_info);

fs/btrfs/lzo.c

248

*out_folio = btrfs_alloc_compr_folio(fs_info);

fs/btrfs/lzo.c

279

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

fs/btrfs/lzo.c

284

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/lzo.c

285

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/lzo.c

299

folio_out = btrfs_alloc_compr_folio(fs_info);

fs/btrfs/lzo.c

335

ret = copy_compressed_data_to_bio(fs_info, bio, workspace->cbuf, out_len,

fs/btrfs/lzo.c

386

struct btrfs_fs_info *fs_info = cb_to_fs_info(cb);

fs/btrfs/lzo.c

387

const u32 min_folio_shift = PAGE_SHIFT + fs_info->block_min_order;

fs/btrfs/lzo.c

432

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

fs/btrfs/lzo.c

433

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/lzo.c

450

ASSERT(folio_size(fi.folio) == btrfs_min_folio_size(fs_info));

fs/btrfs/lzo.c

467

btrfs_err(fs_info,

fs/btrfs/lzo.c

495

if (unlikely(seg_len > workspace_cbuf_length(fs_info))) {

fs/btrfs/lzo.c

502

btrfs_err(fs_info,

fs/btrfs/lzo.c

519

btrfs_err(fs_info,

fs/btrfs/lzo.c

552

struct btrfs_fs_info *fs_info = folio_to_fs_info(dest_folio);

fs/btrfs/lzo.c

553

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/lzo.c

556

size_t max_segment_len = workspace_buf_length(fs_info);

fs/btrfs/lzo.c

577

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

1231

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ordered-data.c

1258

const int fs_error = BTRFS_FS_ERROR(fs_info);

fs/btrfs/ordered-data.c

1335

btrfs_panic(fs_info, -EEXIST,

fs/btrfs/ordered-data.c

218

btrfs_qgroup_free_refroot(inode->root->fs_info,

fs/btrfs/ordered-data.c

229

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ordered-data.c

234

percpu_counter_add_batch(&fs_info->ordered_bytes, entry->num_bytes,

fs/btrfs/ordered-data.c

235

fs_info->delalloc_batch);

fs/btrfs/ordered-data.c

244

btrfs_panic(fs_info, -EEXIST,

fs/btrfs/ordered-data.c

254

spin_lock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

256

list_add_tail(&root->ordered_root, &fs_info->ordered_roots);

fs/btrfs/ordered-data.c

257

spin_unlock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

355

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

fs/btrfs/ordered-data.c

370

if (!btrfs_folio_test_ordered(fs_info, folio, file_offset, len))

fs/btrfs/ordered-data.c

372

btrfs_folio_clear_ordered(fs_info, folio, file_offset, len);

fs/btrfs/ordered-data.c

377

btrfs_crit(fs_info,

fs/btrfs/ordered-data.c

407

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

fs/btrfs/ordered-data.c

409

fs_info->endio_freespace_worker : fs_info->endio_write_workers;

fs/btrfs/ordered-data.c

590

btrfs_crit(inode->root->fs_info,

fs/btrfs/ordered-data.c

645

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ordered-data.c

656

btrfs_lockdep_acquire(fs_info, btrfs_trans_pending_ordered);

fs/btrfs/ordered-data.c

661

if (root != fs_info->tree_root) {

fs/btrfs/ordered-data.c

673

percpu_counter_add_batch(&fs_info->ordered_bytes, -entry->num_bytes,

fs/btrfs/ordered-data.c

674

fs_info->delalloc_batch);

fs/btrfs/ordered-data.c

699

spin_lock(&fs_info->trans_lock);

fs/btrfs/ordered-data.c

700

trans = fs_info->running_transaction;

fs/btrfs/ordered-data.c

703

spin_unlock(&fs_info->trans_lock);

fs/btrfs/ordered-data.c

705

ASSERT(trans || BTRFS_FS_ERROR(fs_info));

fs/btrfs/ordered-data.c

713

btrfs_lockdep_release(fs_info, btrfs_trans_pending_ordered);

fs/btrfs/ordered-data.c

722

spin_lock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

725

spin_unlock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

730

btrfs_lockdep_release(fs_info, btrfs_ordered_extent);

fs/btrfs/ordered-data.c

749

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/ordered-data.c

789

btrfs_queue_work(fs_info->flush_workers, &ordered->flush_work);

fs/btrfs/ordered-data.c

816

void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, u64 nr,

fs/btrfs/ordered-data.c

823

mutex_lock(&fs_info->ordered_operations_mutex);

fs/btrfs/ordered-data.c

824

spin_lock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

825

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

fs/btrfs/ordered-data.c

832

&fs_info->ordered_roots);

fs/btrfs/ordered-data.c

833

spin_unlock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

841

spin_lock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

843

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

fs/btrfs/ordered-data.c

844

spin_unlock(&fs_info->ordered_root_lock);

fs/btrfs/ordered-data.c

845

mutex_unlock(&fs_info->ordered_operations_mutex);

fs/btrfs/ordered-data.c

891

btrfs_might_wait_for_event(inode->root->fs_info, btrfs_ordered_extent);

fs/btrfs/ordered-data.h

215

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

268

btrfs_warn(root->fs_info,

fs/btrfs/props.c

307

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

fs/btrfs/props.c

330

btrfs_set_fs_incompat(fs_info, COMPRESS_LZO);

fs/btrfs/props.c

335

btrfs_set_fs_incompat(fs_info, COMPRESS_ZSTD);

fs/btrfs/props.c

393

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/props.c

432

num_bytes = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/props.c

433

ret = btrfs_block_rsv_add(fs_info, trans->block_rsv,

fs/btrfs/props.c

452

btrfs_block_rsv_release(fs_info, trans->block_rsv,

fs/btrfs/qgroup.c

1003

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/qgroup.c

1022

lockdep_assert_held_write(&fs_info->subvol_sem);

fs/btrfs/qgroup.c

1024

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/qgroup.c

1025

btrfs_err(fs_info,

fs/btrfs/qgroup.c

1030

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1031

if (fs_info->quota_root)

fs/btrfs/qgroup.c

1034

ret = btrfs_sysfs_add_qgroups(fs_info);

fs/btrfs/qgroup.c

1051

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1063

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1070

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

1106

fs_info->qgroup_flags = BTRFS_QGROUP_STATUS_FLAG_ON;

fs/btrfs/qgroup.c

1108

fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE;

fs/btrfs/qgroup.c

1109

btrfs_set_fs_incompat(fs_info, SIMPLE_QUOTA);

fs/btrfs/qgroup.c

1112

fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;

fs/btrfs/qgroup.c

1114

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

1157

qgroup = add_qgroup_rb(fs_info, prealloc, found_key.offset);

fs/btrfs/qgroup.c

1159

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

1205

qgroup = add_qgroup_rb(fs_info, prealloc, BTRFS_FS_TREE_OBJECTID);

fs/btrfs/qgroup.c

1207

ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

1213

fs_info->qgroup_enable_gen = trans->transid;

fs/btrfs/qgroup.c

1215

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1227

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1236

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1237

fs_info->quota_root = quota_root;

fs/btrfs/qgroup.c

1238

set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);

fs/btrfs/qgroup.c

1239

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1242

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

1245

ret = qgroup_rescan_init(fs_info, 0, 1);

fs/btrfs/qgroup.c

1247

qgroup_rescan_zero_tracking(fs_info);

fs/btrfs/qgroup.c

1248

fs_info->qgroup_rescan_running = true;

fs/btrfs/qgroup.c

1249

btrfs_queue_work(fs_info->qgroup_rescan_workers,

fs/btrfs/qgroup.c

125

qgroup_rsv_release(fs_info, dest, src->rsv.values[i], i);

fs/btrfs/qgroup.c

1250

&fs_info->qgroup_rescan_work);

fs/btrfs/qgroup.c

1275

btrfs_sysfs_del_qgroups(fs_info);

fs/btrfs/qgroup.c

1276

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1300

static int flush_reservations(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

1304

ret = btrfs_start_delalloc_roots(fs_info, LONG_MAX, false);

fs/btrfs/qgroup.c

1307

btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);

fs/btrfs/qgroup.c

1309

return btrfs_commit_current_transaction(fs_info->tree_root);

fs/btrfs/qgroup.c

1312

int btrfs_quota_disable(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

1322

lockdep_assert_held_write(&fs_info->subvol_sem);

fs/btrfs/qgroup.c

1328

lockdep_assert_held(&fs_info->cleaner_mutex);

fs/btrfs/qgroup.c

1330

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1331

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

1340

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1347

clear_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);

fs/btrfs/qgroup.c

1348

btrfs_qgroup_wait_for_completion(fs_info, false);

fs/btrfs/qgroup.c

1355

ret = flush_reservations(fs_info);

fs/btrfs/qgroup.c

1357

set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);

fs/btrfs/qgroup.c

1370

trans = btrfs_start_transaction(fs_info->tree_root, 1);

fs/btrfs/qgroup.c

1372

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1376

set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);

fs/btrfs/qgroup.c

1380

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

1383

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1384

quota_root = fs_info->quota_root;

fs/btrfs/qgroup.c

1385

fs_info->quota_root = NULL;

fs/btrfs/qgroup.c

1386

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_ON;

fs/btrfs/qgroup.c

1387

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE;

fs/btrfs/qgroup.c

1388

fs_info->qgroup_drop_subtree_thres = BTRFS_QGROUP_DROP_SUBTREE_THRES_DEFAULT;

fs/btrfs/qgroup.c

1389

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1391

btrfs_free_qgroup_config(fs_info);

fs/btrfs/qgroup.c

1405

spin_lock(&fs_info->trans_lock);

fs/btrfs/qgroup.c

1407

spin_unlock(&fs_info->trans_lock);

fs/btrfs/qgroup.c

1420

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1428

static void qgroup_dirty(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

1432

list_add(&qgroup->dirty, &fs_info->dirty_qgroups);

fs/btrfs/qgroup.c

1467

static int __qgroup_excl_accounting(struct btrfs_fs_info *fs_info, u64 ref_root,

fs/btrfs/qgroup.c

1476

qgroup = find_qgroup_rb(fs_info, ref_root);

fs/btrfs/qgroup.c

1493

qgroup_rsv_add_by_qgroup(fs_info, qgroup, src);

fs/btrfs/qgroup.c

1495

qgroup_rsv_release_by_qgroup(fs_info, qgroup, src);

fs/btrfs/qgroup.c

1496

qgroup_dirty(fs_info, qgroup);

fs/btrfs/qgroup.c

1520

static int quick_update_accounting(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

1526

qgroup = find_qgroup_rb(fs_info, src);

fs/btrfs/qgroup.c

1530

ret = __qgroup_excl_accounting(fs_info, dst, qgroup, sign);

fs/btrfs/qgroup.c

1537

fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;

fs/btrfs/qgroup.c

1548

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

1562

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1563

if (!fs_info->quota_root) {

fs/btrfs/qgroup.c

1567

member = find_qgroup_rb(fs_info, src);

fs/btrfs/qgroup.c

1568

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

1592

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1596

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1599

ret = quick_update_accounting(fs_info, src, dst, 1);

fs/btrfs/qgroup.c

1600

squota_check_parent_usage(fs_info, parent);

fs/btrfs/qgroup.c

1601

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1604

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

161

static void qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info);

fs/btrfs/qgroup.c

1611

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

1619

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

1622

member = find_qgroup_rb(fs_info, src);

fs/btrfs/qgroup.c

1623

parent = find_qgroup_rb(fs_info, dst);

fs/btrfs/qgroup.c

1652

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1653

del_relation_rb(fs_info, src, dst);

fs/btrfs/qgroup.c

1654

ret = quick_update_accounting(fs_info, src, dst, -1);

fs/btrfs/qgroup.c

1656

squota_check_parent_usage(fs_info, parent);

fs/btrfs/qgroup.c

1657

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1666

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

1669

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1671

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1678

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

1684

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1685

if (!fs_info->quota_root) {

fs/btrfs/qgroup.c

1689

quota_root = fs_info->quota_root;

fs/btrfs/qgroup.c

1690

qgroup = find_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

1706

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1707

qgroup = add_qgroup_rb(fs_info, prealloc, qgroupid);

fs/btrfs/qgroup.c

1708

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1711

ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

1713

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1736

static bool can_delete_squota_qgroup(struct btrfs_fs_info *fs_info, struct btrfs_qgroup *qgroup)

fs/btrfs/qgroup.c

1738

ASSERT(btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE);

fs/btrfs/qgroup.c

1741

squota_check_parent_usage(fs_info, qgroup);

fs/btrfs/qgroup.c

1753

static int can_delete_qgroup(struct btrfs_fs_info *fs_info, struct btrfs_qgroup *qgroup)

fs/btrfs/qgroup.c

1759

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

1760

return can_delete_squota_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

177

static struct btrfs_qgroup *find_qgroup_rb(const struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

1783

return btrfs_find_root(fs_info->tree_root, &key, path, NULL, NULL);

fs/btrfs/qgroup.c

1788

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

1793

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1794

if (!fs_info->quota_root) {

fs/btrfs/qgroup.c

1799

qgroup = find_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

1805

ret = can_delete_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

182

node = rb_find(&qgroupid, &fs_info->qgroup_tree, btrfs_qgroup_qgroupid_key_cmp);

fs/btrfs/qgroup.c

1832

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1843

btrfs_warn_rl(fs_info,

fs/btrfs/qgroup.c

1858

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_FULL &&

fs/btrfs/qgroup.c

1859

!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT)) {

fs/btrfs/qgroup.c

1863

qgroup_mark_inconsistent(fs_info,

fs/btrfs/qgroup.c

1871

del_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

1872

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1879

btrfs_sysfs_del_one_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

1882

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1886

int btrfs_qgroup_cleanup_dropped_subvolume(struct btrfs_fs_info *fs_info, u64 subvolid)

fs/btrfs/qgroup.c

1891

if (!btrfs_is_fstree(subvolid) || !btrfs_qgroup_enabled(fs_info) ||

fs/btrfs/qgroup.c

1892

!fs_info->quota_root)

fs/btrfs/qgroup.c

1899

ret = btrfs_commit_current_transaction(fs_info->quota_root);

fs/btrfs/qgroup.c

1904

trans = btrfs_start_transaction(fs_info->quota_root, 2);

fs/btrfs/qgroup.c

1924

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

1933

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

1934

if (!fs_info->quota_root) {

fs/btrfs/qgroup.c

1939

qgroup = find_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

1945

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1984

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

1988

qgroup_mark_inconsistent(fs_info, "qgroup item update error %d", ret);

fs/btrfs/qgroup.c

1991

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

2006

int btrfs_qgroup_trace_extent_nolock(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

201

static struct btrfs_qgroup *add_qgroup_rb(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

2012

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

fs/btrfs/qgroup.c

2014

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

2019

btrfs_err_rl(fs_info,

fs/btrfs/qgroup.c

2022

btrfs_err_32bit_limit(fs_info);

fs/btrfs/qgroup.c

2027

trace_btrfs_qgroup_trace_extent(fs_info, record, bytenr);

fs/btrfs/qgroup.c

2043

qgroup_mark_inconsistent(fs_info, "xarray insert error: %d", xa_err(ret));

fs/btrfs/qgroup.c

2075

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2078

.fs_info = fs_info,

fs/btrfs/qgroup.c

2082

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

2105

if (fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_NO_ACCOUNTING)

fs/btrfs/qgroup.c

211

node = rb_find_add(&prealloc->node, &fs_info->qgroup_tree, btrfs_qgroup_qgroupid_cmp);

fs/btrfs/qgroup.c

2110

qgroup_mark_inconsistent(fs_info,

fs/btrfs/qgroup.c

2142

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2145

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

fs/btrfs/qgroup.c

2148

if (!btrfs_qgroup_full_accounting(fs_info) || bytenr == 0 || num_bytes == 0)

fs/btrfs/qgroup.c

2161

ret = btrfs_qgroup_trace_extent_nolock(fs_info, delayed_refs, record, bytenr);

fs/btrfs/qgroup.c

2180

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2188

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

2333

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2334

u32 nodesize = fs_info->nodesize;

fs/btrfs/qgroup.c

2450

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2460

btrfs_err_rl(fs_info,

fs/btrfs/qgroup.c

2476

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

251

struct btrfs_qgroup *qgroup = find_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

2550

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2555

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

256

rb_erase(&qgroup->node, &fs_info->qgroup_tree);

fs/btrfs/qgroup.c

2560

btrfs_err_rl(fs_info,

fs/btrfs/qgroup.c

2594

qgroup_mark_inconsistent(fs_info, "%s error: %d", __func__, ret);

fs/btrfs/qgroup.c

2612

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2622

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

2625

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

2626

drop_subptree_thres = fs_info->qgroup_drop_subtree_thres;

fs/btrfs/qgroup.c

2627

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

2638

qgroup_mark_inconsistent(fs_info, "subtree level reached threshold");

fs/btrfs/qgroup.c

2699

fs_info->nodesize);

fs/btrfs/qgroup.c

2748

static void qgroup_update_refcnt(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

2762

qg = find_qgroup_rb(fs_info, unode->val);

fs/btrfs/qgroup.c

2821

static void qgroup_update_counters(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

2834

trace_btrfs_qgroup_update_counters(fs_info, qg, cur_old_count,

fs/btrfs/qgroup.c

2899

qgroup_dirty(fs_info, qg);

fs/btrfs/qgroup.c

2936

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

2947

if (!btrfs_qgroup_full_accounting(fs_info) ||

fs/btrfs/qgroup.c

2948

fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_NO_ACCOUNTING)

fs/btrfs/qgroup.c

2966

trace_btrfs_qgroup_account_extent(fs_info, trans->transid, bytenr,

fs/btrfs/qgroup.c

2969

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

297

static int add_relation_rb(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

2970

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {

fs/btrfs/qgroup.c

2971

if (fs_info->qgroup_rescan_progress.objectid <= bytenr) {

fs/btrfs/qgroup.c

2972

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

2977

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

2979

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

2980

seq = fs_info->qgroup_seq;

fs/btrfs/qgroup.c

2983

qgroup_update_refcnt(fs_info, old_roots, &qgroups, seq, UPDATE_OLD);

fs/btrfs/qgroup.c

2986

qgroup_update_refcnt(fs_info, new_roots, &qgroups, seq, UPDATE_NEW);

fs/btrfs/qgroup.c

2988

qgroup_update_counters(fs_info, &qgroups, nr_old_roots, nr_new_roots,

fs/btrfs/qgroup.c

3001

fs_info->qgroup_seq += max(nr_old_roots, nr_new_roots) + 1;

fs/btrfs/qgroup.c

3002

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3011

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

3020

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

3026

const u64 bytenr = (((u64)index) << fs_info->sectorsize_bits);

fs/btrfs/qgroup.c

3029

trace_btrfs_qgroup_account_extents(fs_info, record, bytenr);

fs/btrfs/qgroup.c

3031

if (!ret && !(fs_info->qgroup_flags &

fs/btrfs/qgroup.c

3036

ctx.fs_info = fs_info;

fs/btrfs/qgroup.c

304

member = find_qgroup_rb(fs_info, memberid);

fs/btrfs/qgroup.c

305

parent = find_qgroup_rb(fs_info, parentid);

fs/btrfs/qgroup.c

3085

btrfs_qgroup_free_refroot(fs_info,

fs/btrfs/qgroup.c

3097

trace_btrfs_qgroup_num_dirty_extents(fs_info, trans->transid, num_dirty_extents);

fs/btrfs/qgroup.c

3107

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

311

static int del_relation_rb(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

3116

lockdep_assert_held(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

3118

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

3121

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3122

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

fs/btrfs/qgroup.c

3124

qgroup = list_first_entry(&fs_info->dirty_qgroups,

fs/btrfs/qgroup.c

3127

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3130

qgroup_mark_inconsistent(fs_info,

fs/btrfs/qgroup.c

3134

qgroup_mark_inconsistent(fs_info,

fs/btrfs/qgroup.c

3136

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3138

if (btrfs_qgroup_enabled(fs_info))

fs/btrfs/qgroup.c

3139

fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_ON;

fs/btrfs/qgroup.c

3141

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_ON;

fs/btrfs/qgroup.c

3142

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3146

qgroup_mark_inconsistent(fs_info,

fs/btrfs/qgroup.c

3152

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

3181

if (!btrfs_qgroup_enabled(fs_info))

fs/btrfs/qgroup.c

319

parent = find_qgroup_rb(fs_info, parentid);

fs/btrfs/qgroup.c

3197

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3198

qgroup = find_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

3200

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3203

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3208

static int qgroup_auto_inherit(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

3223

inode_qg = find_qgroup_rb(fs_info, inode_rootid);

fs/btrfs/qgroup.c

3258

static int qgroup_snapshot_quick_inherit(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

3266

const u32 nodesize = fs_info->nodesize;

fs/btrfs/qgroup.c

3269

if (btrfs_qgroup_mode(fs_info) != BTRFS_QGROUP_MODE_FULL)

fs/btrfs/qgroup.c

3272

src = find_qgroup_rb(fs_info, srcid);

fs/btrfs/qgroup.c

3275

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

3312

qgroup_dirty(fs_info, qgroup);

fs/btrfs/qgroup.c

3335

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

3346

if (!btrfs_qgroup_enabled(fs_info))

fs/btrfs/qgroup.c

335

int btrfs_verify_qgroup_counts(const struct btrfs_fs_info *fs_info, u64 qgroupid,

fs/btrfs/qgroup.c

3365

spin_lock(&fs_info->trans_lock);

fs/btrfs/qgroup.c

3368

spin_unlock(&fs_info->trans_lock);

fs/btrfs/qgroup.c

3371

mutex_lock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

3373

quota_root = fs_info->quota_root;

fs/btrfs/qgroup.c

3379

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE && !inherit) {

fs/btrfs/qgroup.c

3380

ret = qgroup_auto_inherit(fs_info, inode_rootid, &inherit);

fs/btrfs/qgroup.c

3391

srcgroup = find_qgroup_rb(fs_info, *i_qgroups);

fs/btrfs/qgroup.c

340

qgroup = find_qgroup_rb(fs_info, qgroupid);

fs/btrfs/qgroup.c

3447

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3449

dstgroup = add_qgroup_rb(fs_info, prealloc, objectid);

fs/btrfs/qgroup.c

3459

qgroup_dirty(fs_info, dstgroup);

fs/btrfs/qgroup.c

3462

if (srcid && btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_FULL) {

fs/btrfs/qgroup.c

3463

srcgroup = find_qgroup_rb(fs_info, srcid);

fs/btrfs/qgroup.c

3472

level_size = fs_info->nodesize;

fs/btrfs/qgroup.c

3487

qgroup_dirty(fs_info, dstgroup);

fs/btrfs/qgroup.c

3488

qgroup_dirty(fs_info, srcgroup);

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

3504

ret = add_relation_rb(fs_info, qlist_prealloc[i], objectid,

fs/btrfs/qgroup.c

3512

ret = qgroup_snapshot_quick_inherit(fs_info, srcid, *i_qgroups);

fs/btrfs/qgroup.c

3529

src = find_qgroup_rb(fs_info, i_qgroups[0]);

fs/btrfs/qgroup.c

3530

dst = find_qgroup_rb(fs_info, i_qgroups[1]);

fs/btrfs/qgroup.c

3550

src = find_qgroup_rb(fs_info, i_qgroups[0]);

fs/btrfs/qgroup.c

3551

dst = find_qgroup_rb(fs_info, i_qgroups[1]);

fs/btrfs/qgroup.c

3564

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3566

ret = btrfs_sysfs_add_one_qgroup(fs_info, dstgroup);

fs/btrfs/qgroup.c

3569

mutex_unlock(&fs_info->qgroup_ioctl_lock);

fs/btrfs/qgroup.c

3571

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

3600

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/qgroup.c

3611

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

fs/btrfs/qgroup.c

3615

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3616

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

3619

qgroup = find_qgroup_rb(fs_info, ref_root);

fs/btrfs/qgroup.c

3641

qgroup_rsv_add(fs_info, qgroup, num_bytes, type);

fs/btrfs/qgroup.c

3645

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3658

void btrfs_qgroup_free_refroot(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

3675

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3677

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

3680

qgroup = find_qgroup_rb(fs_info, ref_root);

fs/btrfs/qgroup.c

3695

qgroup_rsv_release(fs_info, qgroup, num_bytes, type);

fs/btrfs/qgroup.c

37

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE)

fs/btrfs/qgroup.c

3702

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

3727

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

3736

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

3739

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3740

extent_root = btrfs_extent_root(fs_info,

fs/btrfs/qgroup.c

3741

fs_info->qgroup_rescan_progress.objectid);

fs/btrfs/qgroup.c

3743

btrfs_err(fs_info,

fs/btrfs/qgroup.c

3745

fs_info->qgroup_rescan_progress.objectid);

fs/btrfs/qgroup.c

3746

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3751

&fs_info->qgroup_rescan_progress,

fs/btrfs/qgroup.c

3754

btrfs_debug(fs_info,

fs/btrfs/qgroup.c

3756

BTRFS_KEY_FMT_VALUE(&fs_info->qgroup_rescan_progress), ret);

fs/btrfs/qgroup.c

3767

fs_info->qgroup_rescan_progress.objectid = (u64)-1;

fs/btrfs/qgroup.c

3769

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3776

fs_info->qgroup_rescan_progress.objectid = found.objectid + 1;

fs/btrfs/qgroup.c

3781

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3786

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3796

num_bytes = fs_info->nodesize;

fs/btrfs/qgroup.c

3801

ctx.fs_info = fs_info;

fs/btrfs/qgroup.c

3818

fs_info->qgroup_rescan_progress.objectid = (u64)-1;

fs/btrfs/qgroup.c

3823

static bool rescan_should_stop(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

3825

if (btrfs_fs_closing(fs_info))

fs/btrfs/qgroup.c

3827

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

fs/btrfs/qgroup.c

3829

if (!btrfs_qgroup_enabled(fs_info))

fs/btrfs/qgroup.c

3831

if (fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN)

fs/btrfs/qgroup.c

3838

struct btrfs_fs_info *fs_info = container_of(work, struct btrfs_fs_info,

fs/btrfs/qgroup.c

3846

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

386

static void qgroup_mark_inconsistent(struct btrfs_fs_info *fs_info, const char *fmt, ...)

fs/btrfs/qgroup.c

3861

while (!ret && !(stopped = rescan_should_stop(fs_info))) {

fs/btrfs/qgroup.c

3862

trans = btrfs_start_transaction(fs_info->fs_root, 0);

fs/btrfs/qgroup.c

388

const u64 old_flags = fs_info->qgroup_flags;

fs/btrfs/qgroup.c

3880

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3882

fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT) {

fs/btrfs/qgroup.c

3883

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;

fs/btrfs/qgroup.c

3885

fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;

fs/btrfs/qgroup.c

3887

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3897

trans = btrfs_start_transaction(fs_info->quota_root, 1);

fs/btrfs/qgroup.c

390

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

3901

btrfs_err(fs_info,

fs/btrfs/qgroup.c

3909

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3911

fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN)

fs/btrfs/qgroup.c

3912

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;

fs/btrfs/qgroup.c

3918

btrfs_err(fs_info, "fail to update qgroup status: %d", ret);

fs/btrfs/qgroup.c

392

fs_info->qgroup_flags |= (BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT |

fs/btrfs/qgroup.c

3921

fs_info->qgroup_rescan_running = false;

fs/btrfs/qgroup.c

3922

fs_info->qgroup_flags &= ~BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN;

fs/btrfs/qgroup.c

3923

complete_all(&fs_info->qgroup_rescan_completion);

fs/btrfs/qgroup.c

3924

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3932

btrfs_info(fs_info, "qgroup scan paused");

fs/btrfs/qgroup.c

3933

} else if (fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN) {

fs/btrfs/qgroup.c

3934

btrfs_info(fs_info, "qgroup scan cancelled");

fs/btrfs/qgroup.c

3936

btrfs_info(fs_info, "qgroup scan completed%s",

fs/btrfs/qgroup.c

3939

btrfs_err(fs_info, "qgroup scan failed with %d", ret);

fs/btrfs/qgroup.c

3948

qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid,

fs/btrfs/qgroup.c

3953

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE) {

fs/btrfs/qgroup.c

3954

btrfs_warn(fs_info, "qgroup rescan init failed, running in simple mode");

fs/btrfs/qgroup.c

3960

if (!(fs_info->qgroup_flags &

fs/btrfs/qgroup.c

3962

btrfs_debug(fs_info,

fs/btrfs/qgroup.c

3965

} else if (!(fs_info->qgroup_flags &

fs/btrfs/qgroup.c

3967

btrfs_debug(fs_info,

fs/btrfs/qgroup.c

3976

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3979

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {

fs/btrfs/qgroup.c

3981

} else if (!(fs_info->qgroup_flags &

fs/btrfs/qgroup.c

3983

btrfs_debug(fs_info,

fs/btrfs/qgroup.c

3986

} else if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED) {

fs/btrfs/qgroup.c

3992

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

3995

fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_RESCAN;

fs/btrfs/qgroup.c

3998

memset(&fs_info->qgroup_rescan_progress, 0,

fs/btrfs/qgroup.c

3999

sizeof(fs_info->qgroup_rescan_progress));

fs/btrfs/qgroup.c

4000

fs_info->qgroup_flags &= ~(BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN |

fs/btrfs/qgroup.c

4002

fs_info->qgroup_rescan_progress.objectid = progress_objectid;

fs/btrfs/qgroup.c

4003

init_completion(&fs_info->qgroup_rescan_completion);

fs/btrfs/qgroup.c

4004

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4006

btrfs_init_work(&fs_info->qgroup_rescan_work,

fs/btrfs/qgroup.c

4012

qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

4017

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

4019

for (n = rb_first(&fs_info->qgroup_tree); n; n = rb_next(n)) {

fs/btrfs/qgroup.c

4025

qgroup_dirty(fs_info, qgroup);

fs/btrfs/qgroup.c

4027

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

403

btrfs_warn_rl(fs_info, "qgroup marked inconsistent, %pV", &vaf);

fs/btrfs/qgroup.c

4031

btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

4035

ret = qgroup_rescan_init(fs_info, 0, 1);

fs/btrfs/qgroup.c

4050

ret = btrfs_commit_current_transaction(fs_info->fs_root);

fs/btrfs/qgroup.c

4052

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;

fs/btrfs/qgroup.c

4056

qgroup_rescan_zero_tracking(fs_info);

fs/btrfs/qgroup.c

4058

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4064

if (btrfs_qgroup_full_accounting(fs_info)) {

fs/btrfs/qgroup.c

4065

fs_info->qgroup_rescan_running = true;

fs/btrfs/qgroup.c

4066

btrfs_queue_work(fs_info->qgroup_rescan_workers,

fs/btrfs/qgroup.c

4067

&fs_info->qgroup_rescan_work);

fs/btrfs/qgroup.c

4071

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4076

int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

408

static void qgroup_read_enable_gen(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

4082

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4083

running = fs_info->qgroup_rescan_running;

fs/btrfs/qgroup.c

4084

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4091

&fs_info->qgroup_rescan_completion);

fs/btrfs/qgroup.c

4093

wait_for_completion(&fs_info->qgroup_rescan_completion);

fs/btrfs/qgroup.c

4103

btrfs_qgroup_rescan_resume(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

4105

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {

fs/btrfs/qgroup.c

4106

mutex_lock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

4107

fs_info->qgroup_rescan_running = true;

fs/btrfs/qgroup.c

4108

btrfs_queue_work(fs_info->qgroup_rescan_workers,

fs/btrfs/qgroup.c

4109

&fs_info->qgroup_rescan_work);

fs/btrfs/qgroup.c

4110

mutex_unlock(&fs_info->qgroup_rescan_lock);

fs/btrfs/qgroup.c

412

ASSERT(btrfs_fs_incompat(fs_info, SIMPLE_QUOTA));

fs/btrfs/qgroup.c

414

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

421

int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

4226

btrfs_run_delayed_iputs(root->fs_info);

fs/btrfs/qgroup.c

4227

btrfs_wait_on_delayed_iputs(root->fs_info);

fs/btrfs/qgroup.c

4247

if (btrfs_qgroup_mode(root->fs_info) == BTRFS_QGROUP_MODE_DISABLED ||

fs/btrfs/qgroup.c

425

struct btrfs_root *quota_root = fs_info->quota_root;

fs/btrfs/qgroup.c

433

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

4330

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

fs/btrfs/qgroup.c

4331

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

fs/btrfs/qgroup.c

4366

btrfs_qgroup_free_refroot(root->fs_info, btrfs_root_id(root), freed,

fs/btrfs/qgroup.c

4384

if (btrfs_qgroup_mode(inode->root->fs_info) == BTRFS_QGROUP_MODE_DISABLED) {

fs/btrfs/qgroup.c

44

return btrfs_qgroup_mode(fs_info) != BTRFS_QGROUP_MODE_DISABLED;

fs/btrfs/qgroup.c

4405

btrfs_qgroup_free_refroot(inode->root->fs_info,

fs/btrfs/qgroup.c

442

ret = btrfs_sysfs_add_qgroups(fs_info);

fs/btrfs/qgroup.c

446

fs_info->qgroup_flags = 0;

fs/btrfs/qgroup.c

4497

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/qgroup.c

4500

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED ||

fs/btrfs/qgroup.c

4504

BUG_ON(num_bytes != round_down(num_bytes, fs_info->nodesize));

fs/btrfs/qgroup.c

4543

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/qgroup.c

4545

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED ||

fs/btrfs/qgroup.c

4552

btrfs_qgroup_free_refroot(fs_info, btrfs_root_id(root), (u64)-1,

fs/btrfs/qgroup.c

4559

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/qgroup.c

4561

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED ||

fs/btrfs/qgroup.c

4571

BUG_ON(num_bytes != round_down(num_bytes, fs_info->nodesize));

fs/btrfs/qgroup.c

4573

btrfs_qgroup_free_refroot(fs_info, btrfs_root_id(root), num_bytes, type);

fs/btrfs/qgroup.c

4576

static void qgroup_convert_meta(struct btrfs_fs_info *fs_info, u64 ref_root,

fs/btrfs/qgroup.c

4584

if (!fs_info->quota_root)

fs/btrfs/qgroup.c

4587

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

4588

qgroup = find_qgroup_rb(fs_info, ref_root);

fs/btrfs/qgroup.c

4596

qgroup_rsv_release(fs_info, qgroup, num_bytes,

fs/btrfs/qgroup.c

4598

if (!sb_rdonly(fs_info->sb))

fs/btrfs/qgroup.c

4599

qgroup_rsv_add(fs_info, qgroup, num_bytes,

fs/btrfs/qgroup.c

4607

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

4618

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/qgroup.c

4620

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED ||

fs/btrfs/qgroup.c

4627

qgroup_convert_meta(fs_info, btrfs_root_id(root), num_bytes);

fs/btrfs/qgroup.c

4628

if (!sb_rdonly(fs_info->sb))

fs/btrfs/qgroup.c

4651

btrfs_warn(inode->root->fs_info,

fs/btrfs/qgroup.c

4655

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

473

btrfs_err(fs_info,

fs/btrfs/qgroup.c

4743

struct btrfs_fs_info *fs_info = subvol_root->fs_info;

fs/btrfs/qgroup.c

4750

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

4755

btrfs_err_rl(fs_info,

fs/btrfs/qgroup.c

477

fs_info->qgroup_flags = btrfs_qgroup_status_flags(l, ptr);

fs/btrfs/qgroup.c

478

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE)

fs/btrfs/qgroup.c

479

qgroup_read_enable_gen(fs_info, l, slot, ptr);

fs/btrfs/qgroup.c

480

else if (btrfs_qgroup_status_generation(l, ptr) != fs_info->generation)

fs/btrfs/qgroup.c

481

qgroup_mark_inconsistent(fs_info, "qgroup generation mismatch");

fs/btrfs/qgroup.c

4820

qgroup_mark_inconsistent(fs_info, "%s error: %d", __func__, ret);

fs/btrfs/qgroup.c

4834

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/qgroup.c

4845

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/qgroup.c

4880

reloc_eb = read_tree_block(fs_info, block->reloc_bytenr, &check);

fs/btrfs/qgroup.c

4897

qgroup_mark_inconsistent(fs_info,

fs/btrfs/qgroup.c

49

return btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_FULL;

fs/btrfs/qgroup.c

490

qgroup = find_qgroup_rb(fs_info, found_key.offset);

fs/btrfs/qgroup.c

4916

int btrfs_record_squota_delta(struct btrfs_fs_info *fs_info,

fs/btrfs/qgroup.c

4927

if (btrfs_qgroup_mode(fs_info) != BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/qgroup.c

493

qgroup_mark_inconsistent(fs_info, "inconsistent qgroup config");

fs/btrfs/qgroup.c

4934

if (delta->generation < fs_info->qgroup_enable_gen)

fs/btrfs/qgroup.c

4937

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

4938

qgroup = find_qgroup_rb(fs_info, root);

fs/btrfs/qgroup.c

4951

qgroup_dirty(fs_info, qg);

fs/btrfs/qgroup.c

4959

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

496

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/qgroup.c

503

qgroup = add_qgroup_rb(fs_info, prealloc, found_key.offset);

fs/btrfs/qgroup.c

524

ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

593

ret = add_relation_rb(fs_info, list, found_key.objectid,

fs/btrfs/qgroup.c

597

btrfs_warn(fs_info,

fs/btrfs/qgroup.c

613

fs_info->qgroup_flags |= flags;

fs/btrfs/qgroup.c

615

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON)

fs/btrfs/qgroup.c

616

set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);

fs/btrfs/qgroup.c

617

if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN)

fs/btrfs/qgroup.c

618

ret = qgroup_rescan_init(fs_info, rescan_progress, 0);

fs/btrfs/qgroup.c

620

fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;

fs/btrfs/qgroup.c

621

btrfs_sysfs_del_qgroups(fs_info);

fs/btrfs/qgroup.c

634

bool btrfs_check_quota_leak(const struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

639

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED)

fs/btrfs/qgroup.c

646

for (node = rb_first(&fs_info->qgroup_tree); node; node = rb_next(node)) {

fs/btrfs/qgroup.c

654

btrfs_warn(fs_info,

fs/btrfs/qgroup.c

669

void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info)

fs/btrfs/qgroup.c

679

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

680

while ((n = rb_first(&fs_info->qgroup_tree))) {

fs/btrfs/qgroup.c

682

rb_erase(n, &fs_info->qgroup_tree);

fs/btrfs/qgroup.c

684

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

685

btrfs_sysfs_del_one_qgroup(fs_info, qgroup);

fs/btrfs/qgroup.c

687

spin_lock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

689

spin_unlock(&fs_info->qgroup_lock);

fs/btrfs/qgroup.c

691

btrfs_sysfs_del_qgroups(fs_info);

fs/btrfs/qgroup.c

697

struct btrfs_root *quota_root = trans->fs_info->quota_root;

fs/btrfs/qgroup.c

716

struct btrfs_root *quota_root = trans->fs_info->quota_root;

fs/btrfs/qgroup.c

748

if (btrfs_is_testing(quota_root->fs_info))

fs/btrfs/qgroup.c

802

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

840

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

878

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

879

struct btrfs_root *quota_root = fs_info->quota_root;

fs/btrfs/qgroup.c

887

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

919

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/qgroup.c

920

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

946

btrfs_set_qgroup_status_flags(l, ptr, fs_info->qgroup_flags &

fs/btrfs/qgroup.c

950

fs_info->qgroup_rescan_progress.objectid);

fs/btrfs/qgroup.c

999

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

453

bool btrfs_check_quota_leak(const struct btrfs_fs_info *fs_info);

fs/btrfs/qgroup.h

454

int btrfs_record_squota_delta(struct btrfs_fs_info *fs_info,

fs/btrfs/raid-stripe-tree.c

152

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

276

ret = btrfs_search_slot(trans, trans->fs_info->stripe_root, key, path,

fs/btrfs/raid-stripe-tree.c

294

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/raid-stripe-tree.c

296

struct btrfs_root *stripe_root = fs_info->stripe_root;

fs/btrfs/raid-stripe-tree.c

309

trace_btrfs_insert_one_raid_extent(fs_info, bioc->logical, bioc->size,

fs/btrfs/raid-stripe-tree.c

344

if (!btrfs_fs_incompat(trans->fs_info, RAID_STRIPE_TREE))

fs/btrfs/raid-stripe-tree.c

363

int btrfs_get_raid_extent_offset(struct btrfs_fs_info *fs_info,

fs/btrfs/raid-stripe-tree.c

367

struct btrfs_root *stripe_root = fs_info->stripe_root;

fs/btrfs/raid-stripe-tree.c

451

trace_btrfs_get_raid_extent_offset(fs_info, logical, *length,

fs/btrfs/raid-stripe-tree.c

463

btrfs_debug(fs_info,

fs/btrfs/raid-stripe-tree.c

64

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/raid-stripe-tree.c

65

struct btrfs_root *stripe_root = fs_info->stripe_root;

fs/btrfs/raid-stripe-tree.c

75

if (!btrfs_fs_incompat(fs_info, RAID_STRIPE_TREE) || !stripe_root)

fs/btrfs/raid-stripe-tree.c

78

if (!btrfs_is_testing(fs_info)) {

fs/btrfs/raid-stripe-tree.c

82

map = btrfs_find_chunk_map(fs_info, start, length);

fs/btrfs/raid-stripe-tree.c

85

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

1061

static struct btrfs_raid_bio *alloc_rbio(struct btrfs_fs_info *fs_info,

fs/btrfs/raid56.c

1068

BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits;

fs/btrfs/raid56.c

1070

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

fs/btrfs/raid56.c

1071

const unsigned int sector_nsteps = fs_info->sectorsize / step;

fs/btrfs/raid56.c

1078

ASSERT(IS_ALIGNED(PAGE_SIZE, fs_info->sectorsize) ||

fs/btrfs/raid56.c

1079

IS_ALIGNED(fs_info->sectorsize, PAGE_SIZE));

fs/btrfs/raid56.c

114

(rbio)->bioc->fs_info : NULL; \

fs/btrfs/raid56.c

1241

const u32 sectorsize = rbio->bioc->fs_info->sectorsize;

fs/btrfs/raid56.c

1310

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

1311

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

fs/btrfs/raid56.c

1312

const u32 step_bits = min(fs_info->sectorsize_bits, PAGE_SHIFT);

fs/btrfs/raid56.c

1412

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

fs/btrfs/raid56.c

1566

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

1569

int total_nr_sector = offset >> fs_info->sectorsize_bits;

fs/btrfs/raid56.c

1574

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

fs/btrfs/raid56.c

1618

const u32 sectorsize = rbio->bioc->fs_info->sectorsize;

fs/btrfs/raid56.c

1670

(bio_size >> rbio->bioc->fs_info->sectorsize_bits); i++)

fs/btrfs/raid56.c

1678

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

1679

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

fs/btrfs/raid56.c

1702

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

fs/btrfs/raid56.c

1709

expected_csum = rbio->csum_buf + total_sector_nr * fs_info->csum_size;

fs/btrfs/raid56.c

1710

btrfs_calculate_block_csum_pages(fs_info, paddrs, csum_buf);

fs/btrfs/raid56.c

1711

if (unlikely(memcmp(csum_buf, expected_csum, fs_info->csum_size) != 0))

fs/btrfs/raid56.c

1836

const struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

1840

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/raid56.c

1855

fs_info->sectorsize_bits) % rbio->stripe_nsectors;

fs/btrfs/raid56.c

186

queue_work(rbio->bioc->fs_info->rmw_workers, &rbio->work);

fs/btrfs/raid56.c

1866

struct btrfs_fs_info *fs_info = bioc->fs_info;

fs/btrfs/raid56.c

1871

rbio = alloc_rbio(fs_info, bioc);

fs/btrfs/raid56.c

1885

cb = blk_check_plugged(raid_unplug, fs_info, sizeof(*plug));

fs/btrfs/raid56.c

1889

plug->info = fs_info;

fs/btrfs/raid56.c

1907

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

1930

fs_info->csum_size;

fs/btrfs/raid56.c

1931

btrfs_calculate_block_csum_pages(fs_info, paddrs, csum_buf);

fs/btrfs/raid56.c

1932

if (unlikely(memcmp(csum_buf, csum_expected, fs_info->csum_size) != 0))

fs/btrfs/raid56.c

1943

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

1944

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

fs/btrfs/raid56.c

2271

struct btrfs_fs_info *fs_info = bioc->fs_info;

fs/btrfs/raid56.c

2274

rbio = alloc_rbio(fs_info, bioc);

fs/btrfs/raid56.c

2299

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

2303

fs_info->sectorsize_bits;

fs/btrfs/raid56.c

2325

fs_info->csum_size, GFP_NOFS);

fs/btrfs/raid56.c

233

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

fs/btrfs/raid56.c

2333

csum_root = btrfs_csum_root(fs_info, rbio->bioc->full_stripe_logical);

fs/btrfs/raid56.c

2335

btrfs_err(fs_info,

fs/btrfs/raid56.c

2346

if (bitmap_empty(rbio->csum_bitmap, len >> fs_info->sectorsize_bits))

fs/btrfs/raid56.c

2356

btrfs_warn_rl(fs_info,

fs/btrfs/raid56.c

2574

struct btrfs_fs_info *fs_info = bioc->fs_info;

fs/btrfs/raid56.c

2578

rbio = alloc_rbio(fs_info, bioc);

fs/btrfs/raid56.c

2609

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

fs/btrfs/raid56.c

2656

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

fs/btrfs/raid56.c

3025

struct btrfs_fs_info *fs_info = rbio->bioc->fs_info;

fs/btrfs/raid56.c

3066

offset_in_full_stripe >> fs_info->sectorsize_bits,

fs/btrfs/raid56.c

3067

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

79

(rbio)->bioc->fs_info : NULL; \

fs/btrfs/raid56.c

798

h = rbio->bioc->fs_info->stripe_hash_table->table + rbio_bucket(rbio);

fs/btrfs/raid56.c

881

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

143

btrfs_folio_set_uptodate(fs_info, folio, file_offset, block_size);

fs/btrfs/reflink.c

144

btrfs_folio_clear_checked(fs_info, folio, file_offset, block_size);

fs/btrfs/reflink.c

145

btrfs_folio_set_dirty(fs_info, folio, file_offset, block_size);

fs/btrfs/reflink.c

177

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/reflink.c

179

fs_info->sectorsize);

fs/btrfs/reflink.c

343

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/reflink.c

357

buf = kvmalloc(fs_info->nodesize, GFP_KERNEL);

fs/btrfs/reflink.c

521

ASSERT(datal <= fs_info->sectorsize);

fs/btrfs/reflink.c

524

WARN_ON(datal > fs_info->sectorsize)) {

fs/btrfs/reflink.c

557

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

637

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

fs/btrfs/reflink.c

638

const u64 bs = fs_info->sectorsize;

fs/btrfs/reflink.c

652

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/reflink.c

666

btrfs_warn_rl(root_dst->fs_info,

fs/btrfs/reflink.c

706

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/reflink.c

709

u64 bs = fs_info->sectorsize;

fs/btrfs/reflink.c

777

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/reflink.c

788

u64 bs = inode_out->root->fs_info->sectorsize;

fs/btrfs/relocation.c

1013

struct btrfs_fs_info *fs_info = dest->fs_info;

fs/btrfs/relocation.c

1077

blocksize = fs_info->nodesize;

fs/btrfs/relocation.c

1334

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

1372

WARN_ON(!IS_ALIGNED(start, fs_info->sectorsize));

fs/btrfs/relocation.c

1387

WARN_ON(!IS_ALIGNED(end, fs_info->sectorsize));

fs/btrfs/relocation.c

1507

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

1564

min_reserved = fs_info->nodesize * reserve_level * 2;

fs/btrfs/relocation.c

1568

ret = btrfs_block_rsv_refill(fs_info, rc->block_rsv,

fs/btrfs/relocation.c

1634

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/relocation.c

1661

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/relocation.c

1673

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

1680

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

1681

rc->merging_rsv_size += fs_info->nodesize * (BTRFS_MAX_LEVEL - 1) * 2;

fs/btrfs/relocation.c

1683

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

1688

ret = btrfs_block_rsv_add(fs_info, rc->block_rsv, num_bytes,

fs/btrfs/relocation.c

1697

btrfs_block_rsv_release(fs_info, rc->block_rsv,

fs/btrfs/relocation.c

1705

btrfs_block_rsv_release(fs_info, rc->block_rsv,

fs/btrfs/relocation.c

1718

root = btrfs_get_fs_root(fs_info, reloc_root->root_key.offset,

fs/btrfs/relocation.c

1734

btrfs_err(fs_info,

fs/btrfs/relocation.c

1748

btrfs_err(fs_info,

fs/btrfs/relocation.c

1809

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

1824

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

1826

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

1832

root = btrfs_get_fs_root(fs_info, reloc_root->root_key.offset,

fs/btrfs/relocation.c

1887

btrfs_handle_fs_error(fs_info, ret, NULL);

fs/btrfs/relocation.c

1891

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

1893

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

191

blocksize = rc->extent_root->fs_info->nodesize;

fs/btrfs/relocation.c

1928

struct btrfs_fs_info *fs_info = reloc_root->fs_info;

fs/btrfs/relocation.c

1935

root = btrfs_get_fs_root(fs_info, reloc_root->root_key.offset, false);

fs/btrfs/relocation.c

1951

btrfs_err(fs_info,

fs/btrfs/relocation.c

1989

btrfs_err(trans->fs_info,

fs/btrfs/relocation.c

1995

btrfs_err(trans->fs_info,

fs/btrfs/relocation.c

2028

btrfs_err(trans->fs_info,

fs/btrfs/relocation.c

2105

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

2120

num_bytes += fs_info->nodesize;

fs/btrfs/relocation.c

2138

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

2149

ret = btrfs_block_rsv_refill(fs_info, rc->block_rsv, num_bytes,

fs/btrfs/relocation.c

2152

u64 tmp = fs_info->nodesize * RELOCATION_RESERVED_NODES;

fs/btrfs/relocation.c

2163

rc->block_rsv->size = tmp + fs_info->nodesize *

fs/btrfs/relocation.c

2267

btrfs_err(root->fs_info,

fs/btrfs/relocation.c

2279

blocksize = root->fs_info->nodesize;

fs/btrfs/relocation.c

2422

u32 blocksize = rc->extent_root->fs_info->nodesize;

fs/btrfs/relocation.c

2430

static int get_tree_block_key(struct btrfs_fs_info *fs_info,

fs/btrfs/relocation.c

2440

eb = read_tree_block(fs_info, block->bytenr, &check);

fs/btrfs/relocation.c

2509

btrfs_err(root->fs_info,

fs/btrfs/relocation.c

2532

btrfs_err(root->fs_info,

fs/btrfs/relocation.c

2553

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

2559

root = btrfs_get_fs_root(fs_info, block->owner, true);

fs/btrfs/relocation.c

2565

num_bytes = fs_info->nodesize * nr_levels;

fs/btrfs/relocation.c

2572

if (root == root->fs_info->chunk_root)

fs/btrfs/relocation.c

2579

if (root == root->fs_info->chunk_root)

fs/btrfs/relocation.c

2595

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

2611

btrfs_readahead_tree_block(fs_info, block->bytenr,

fs/btrfs/relocation.c

2619

ret = get_tree_block_key(fs_info, block);

fs/btrfs/relocation.c

2759

noinline int btrfs_should_cancel_balance(const struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

2761

return atomic_read(&fs_info->balance_cancel_req) ||

fs/btrfs/relocation.c

2762

atomic_read(&fs_info->reloc_cancel_req) ||

fs/btrfs/relocation.c

2784

struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);

fs/btrfs/relocation.c

2795

const bool use_rst = btrfs_need_stripe_tree_update(fs_info, rc->block_group->flags);

fs/btrfs/relocation.c

2888

btrfs_folio_set_dirty(fs_info, folio, clamped_start, clamped_len);

fs/btrfs/relocation.c

2902

fs_info->sectorsize - 1;

fs/btrfs/relocation.c

2925

btrfs_throttle(fs_info);

fs/btrfs/relocation.c

2926

if (btrfs_should_cancel_balance(fs_info))

fs/btrfs/relocation.c

293

root->fs_info->running_transaction->transid)

fs/btrfs/relocation.c

306

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

fs/btrfs/relocation.c

308

struct reloc_control *rc = fs_info->reloc_ctl;

fs/btrfs/relocation.c

3107

btrfs_err(rc->block_group->fs_info,

fs/btrfs/relocation.c

3123

block->key.objectid = rc->extent_root->fs_info->nodesize;

fs/btrfs/relocation.c

3131

btrfs_backref_panic(rc->extent_root->fs_info, block->bytenr,

fs/btrfs/relocation.c

3144

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

3148

bool skinny = btrfs_fs_incompat(fs_info, SKINNY_METADATA);

fs/btrfs/relocation.c

3196

btrfs_err(fs_info,

fs/btrfs/relocation.c

3210

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/relocation.c

3211

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/relocation.c

3225

ret = btrfs_check_trunc_cache_free_space(fs_info,

fs/btrfs/relocation.c

3226

&fs_info->global_block_rsv);

fs/btrfs/relocation.c

3239

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/relocation.c

3296

const u32 blocksize = rc->extent_root->fs_info->nodesize;

fs/btrfs/relocation.c

3303

ctx.fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

3314

eb = read_tree_block(ctx.fs_info, ref_node->val, &check);

fs/btrfs/relocation.c

3341

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

3395

key.objectid + fs_info->nodesize <=

fs/btrfs/relocation.c

3413

fs_info->nodesize;

fs/btrfs/relocation.c

3424

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

3426

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

3427

fs_info->reloc_ctl = rc;

fs/btrfs/relocation.c

3428

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

3433

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

3435

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

3436

fs_info->reloc_ctl = NULL;

fs/btrfs/relocation.c

3437

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

3446

rc->block_rsv = btrfs_alloc_block_rsv(rc->extent_root->fs_info,

fs/btrfs/relocation.c

3457

rc->block_rsv->size = rc->extent_root->fs_info->nodesize *

fs/btrfs/relocation.c

3459

ret = btrfs_block_rsv_refill(rc->extent_root->fs_info,

fs/btrfs/relocation.c

3488

struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;

fs/btrfs/relocation.c

3512

ret = btrfs_block_rsv_refill(fs_info, rc->block_rsv,

fs/btrfs/relocation.c

3549

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE) {

fs/btrfs/relocation.c

3551

u64 owning_root_id = btrfs_get_extent_owner_root(fs_info,

fs/btrfs/relocation.c

3585

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/relocation.c

3597

if (btrfs_should_cancel_balance(fs_info)) {

fs/btrfs/relocation.c

3616

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/relocation.c

3619

if (!err && !btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/relocation.c

3629

btrfs_block_rsv_release(fs_info, rc->block_rsv, (u64)-1, NULL);

fs/btrfs/relocation.c

3645

btrfs_block_rsv_release(fs_info, rc->block_rsv, (u64)-1, NULL);

fs/btrfs/relocation.c

3660

btrfs_free_block_rsv(fs_info, rc->block_rsv);

fs/btrfs/relocation.c

3726

struct btrfs_fs_info *fs_info = group->fs_info;

fs/btrfs/relocation.c

3733

root = btrfs_grab_root(fs_info->data_reloc_root);

fs/btrfs/relocation.c

3761

btrfs_btree_balance_dirty(fs_info);

fs/btrfs/relocation.c

3780

static int reloc_chunk_start(struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

3782

if (test_and_set_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags)) {

fs/btrfs/relocation.c

3784

btrfs_err(fs_info, "reloc already running, cannot start");

fs/btrfs/relocation.c

3788

if (atomic_read(&fs_info->reloc_cancel_req) > 0) {

fs/btrfs/relocation.c

3789

btrfs_info(fs_info, "chunk relocation canceled on start");

fs/btrfs/relocation.c

3791

clear_and_wake_up_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags);

fs/btrfs/relocation.c

3792

atomic_set(&fs_info->reloc_cancel_req, 0);

fs/btrfs/relocation.c

3802

static void reloc_chunk_end(struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

3804

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

fs/btrfs/relocation.c

3806

if (atomic_read(&fs_info->reloc_cancel_req) > 0)

fs/btrfs/relocation.c

3807

btrfs_info(fs_info, "chunk relocation canceled during operation");

fs/btrfs/relocation.c

3808

clear_and_wake_up_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags);

fs/btrfs/relocation.c

3809

atomic_set(&fs_info->reloc_cancel_req, 0);

fs/btrfs/relocation.c

3812

static struct reloc_control *alloc_reloc_control(struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

3822

btrfs_backref_init_cache(fs_info, &rc->backref_cache, true);

fs/btrfs/relocation.c

3825

btrfs_extent_io_tree_init(fs_info, &rc->processed_blocks, IO_TREE_RELOC_BLOCKS);

fs/btrfs/relocation.c

3850

btrfs_info(block_group->fs_info, "relocating block group %llu flags %s",

fs/btrfs/relocation.c

3867

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

3872

max_items = BTRFS_LEAF_DATA_SIZE(trans->fs_info) / sizeof(struct btrfs_item);

fs/btrfs/relocation.c

3884

ret = btrfs_insert_empty_items(trans, fs_info->remap_root, path, &batch);

fs/btrfs/relocation.c

3943

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

3966

btrfs_inc_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/relocation.c

3989

static int copy_remapped_data_io(struct btrfs_fs_info *fs_info,

fs/btrfs/relocation.c

4001

bbio = btrfs_bio_alloc(BIO_MAX_VECS, op, BTRFS_I(fs_info->btree_inode),

fs/btrfs/relocation.c

4015

BTRFS_I(fs_info->btree_inode),

fs/btrfs/relocation.c

4036

static int copy_remapped_data(struct btrfs_fs_info *fs_info, u64 old_addr,

fs/btrfs/relocation.c

4062

ret = copy_remapped_data_io(fs_info, &priv, pages, old_addr,

fs/btrfs/relocation.c

4067

ret = copy_remapped_data_io(fs_info, &priv, pages, new_addr,

fs/btrfs/relocation.c

4095

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4105

ret = btrfs_insert_empty_item(trans, fs_info->remap_root, path,

fs/btrfs/relocation.c

4124

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4134

ret = btrfs_insert_empty_item(trans, fs_info->remap_root, path, &key,

fs/btrfs/relocation.c

4149

static int move_existing_remap(struct btrfs_fs_info *fs_info,

fs/btrfs/relocation.c

4172

min_size = fs_info->sectorsize;

fs/btrfs/relocation.c

4174

min_size = fs_info->nodesize;

fs/btrfs/relocation.c

4176

ret = btrfs_reserve_extent(fs_info->fs_root, length, length, min_size,

fs/btrfs/relocation.c

4188

dest_bg = btrfs_lookup_block_group(fs_info, dest_addr);

fs/btrfs/relocation.c

419

iter = btrfs_backref_iter_alloc(rc->extent_root->fs_info);

fs/btrfs/relocation.c

4190

if (!is_data && !IS_ALIGNED(dest_length, fs_info->nodesize)) {

fs/btrfs/relocation.c

4191

u64 new_length = ALIGN_DOWN(dest_length, fs_info->nodesize);

fs/btrfs/relocation.c

4193

btrfs_free_reserved_extent(fs_info, dest_addr + new_length,

fs/btrfs/relocation.c

4199

trans = btrfs_join_transaction(fs_info->remap_root);

fs/btrfs/relocation.c

4206

mutex_lock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

4214

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, 0, 1);

fs/btrfs/relocation.c

4229

ret = copy_remapped_data(fs_info, new_addr, dest_addr, dest_length);

fs/btrfs/relocation.c

4259

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, -1, 1);

fs/btrfs/relocation.c

4271

ret = btrfs_del_item(trans, fs_info->remap_root, path);

fs/btrfs/relocation.c

4323

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

4325

btrfs_dec_block_group_reservations(fs_info, dest_addr);

fs/btrfs/relocation.c

4328

btrfs_free_reserved_extent(fs_info, dest_addr, dest_length, 0);

fs/btrfs/relocation.c

4345

static int move_existing_remaps(struct btrfs_fs_info *fs_info,

fs/btrfs/relocation.c

4361

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

fs/btrfs/relocation.c

4368

ret = btrfs_next_leaf(fs_info->remap_root, path);

fs/btrfs/relocation.c

4388

ret = btrfs_next_leaf(fs_info->remap_root, path);

fs/btrfs/relocation.c

4410

ret = move_existing_remap(fs_info, path, bg, key.objectid,

fs/btrfs/relocation.c

4425

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4519

parse_bitmap(fs_info->sectorsize, bitmap,

fs/btrfs/relocation.c

4607

struct btrfs_root *remap_root = trans->fs_info->remap_root;

fs/btrfs/relocation.c

4659

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4671

ret = btrfs_search_slot(trans, fs_info->chunk_root, &key, path, 0, 1);

fs/btrfs/relocation.c

4700

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/relocation.c

4720

trans = btrfs_start_transaction_fallback_global_rsv(fs_info->tree_root, num_items);

fs/btrfs/relocation.c

4731

mutex_lock(&trans->fs_info->chunk_mutex);

fs/btrfs/relocation.c

4735

mutex_unlock(&trans->fs_info->chunk_mutex);

fs/btrfs/relocation.c

4741

mutex_unlock(&trans->fs_info->chunk_mutex);

fs/btrfs/relocation.c

4743

write_lock(&trans->fs_info->mapping_tree_lock);

fs/btrfs/relocation.c

4745

write_unlock(&trans->fs_info->mapping_tree_lock);

fs/btrfs/relocation.c

4770

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4798

btrfs_inc_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/relocation.c

4809

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

481

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

4818

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, -1, 1);

fs/btrfs/relocation.c

484

struct reloc_control *rc = fs_info->reloc_ctl;

fs/btrfs/relocation.c

4840

ret = btrfs_del_item(trans, fs_info->remap_root, path);

fs/btrfs/relocation.c

4866

ret = btrfs_insert_empty_item(trans, fs_info->remap_root,

fs/btrfs/relocation.c

4893

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

4901

read_lock(&fs_info->mapping_tree_lock);

fs/btrfs/relocation.c

4903

chunk_map = btrfs_find_chunk_map_nolock(fs_info, start, 1);

fs/btrfs/relocation.c

4905

read_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/relocation.c

4912

read_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/relocation.c

4918

ret = btrfs_search_slot(trans, fs_info->chunk_root, &key, path, 0, 1);

fs/btrfs/relocation.c

4939

static int do_remap_reloc_trans(struct btrfs_fs_info *fs_info,

fs/btrfs/relocation.c

4955

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

fs/btrfs/relocation.c

4957

btrfs_err(fs_info,

fs/btrfs/relocation.c

4967

mutex_lock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

497

btrfs_err(fs_info,

fs/btrfs/relocation.c

4975

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

4986

min_size = fs_info->sectorsize;

fs/btrfs/relocation.c

4988

min_size = fs_info->nodesize;

fs/btrfs/relocation.c

4999

ret = btrfs_reserve_extent(fs_info->fs_root, remap_length, remap_length,

fs/btrfs/relocation.c

5006

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

5016

if (!is_data && !IS_ALIGNED(length, fs_info->nodesize)) {

fs/btrfs/relocation.c

5017

u64 new_length = ALIGN_DOWN(length, fs_info->nodesize);

fs/btrfs/relocation.c

5019

btrfs_free_reserved_extent(fs_info, new_addr + new_length,

fs/btrfs/relocation.c

5025

dest_bg = btrfs_lookup_block_group(fs_info, new_addr);

fs/btrfs/relocation.c

5038

ret = copy_remapped_data(fs_info, start, new_addr, length);

fs/btrfs/relocation.c

5064

btrfs_dec_block_group_reservations(fs_info, new_addr);

fs/btrfs/relocation.c

5066

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

5097

btrfs_free_reserved_extent(fs_info, new_addr, length, 0);

fs/btrfs/relocation.c

5099

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

5105

static int do_remap_reloc(struct btrfs_fs_info *fs_info, struct btrfs_path *path,

fs/btrfs/relocation.c

5112

ret = do_remap_reloc_trans(fs_info, bg, path, &last_start);

fs/btrfs/relocation.c

5123

int btrfs_translate_remap(struct btrfs_fs_info *fs_info, u64 *logical, u64 *length)

fs/btrfs/relocation.c

513

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

5139

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

fs/btrfs/relocation.c

516

struct reloc_control *rc = fs_info->reloc_ctl;

fs/btrfs/relocation.c

5173

static int start_block_group_remapping(struct btrfs_fs_info *fs_info,

fs/btrfs/relocation.c

5185

trans = btrfs_start_transaction(fs_info->remap_root, 0);

fs/btrfs/relocation.c

5196

mutex_lock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

5223

btrfs_inc_delayed_refs_rsv_bg_updates(fs_info);

fs/btrfs/relocation.c

5240

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

5249

static int do_nonremap_reloc(struct btrfs_fs_info *fs_info, bool verbose,

fs/btrfs/relocation.c

5257

mutex_lock(&fs_info->cleaner_mutex);

fs/btrfs/relocation.c

5259

mutex_unlock(&fs_info->cleaner_mutex);

fs/btrfs/relocation.c

5289

btrfs_info(fs_info, "found %llu extents, stage: %s",

fs/btrfs/relocation.c

5303

int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 group_start,

fs/btrfs/relocation.c

5307

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

fs/btrfs/relocation.c

5315

btrfs_err(fs_info,

fs/btrfs/relocation.c

5326

ret = wait_on_bit(&fs_info->flags, BTRFS_FS_UNFINISHED_DROPS, TASK_INTERRUPTIBLE);

fs/btrfs/relocation.c

5331

if (btrfs_fs_closing(fs_info))

fs/btrfs/relocation.c

5334

bg = btrfs_lookup_block_group(fs_info, group_start);

fs/btrfs/relocation.c

5347

ASSERT(sb_write_started(fs_info->sb));

fs/btrfs/relocation.c

5349

if (btrfs_pinned_by_swapfile(fs_info, bg)) {

fs/btrfs/relocation.c

5354

rc = alloc_reloc_control(fs_info);

fs/btrfs/relocation.c

5360

ret = reloc_chunk_start(fs_info);

fs/btrfs/relocation.c

5389

if (!btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/relocation.c

540

spin_lock(&fs_info->trans_lock);

fs/btrfs/relocation.c

5403

btrfs_wait_ordered_roots(fs_info, U64_MAX, rc->block_group);

fs/btrfs/relocation.c

5410

ret = move_existing_remaps(fs_info, bg, path);

fs/btrfs/relocation.c

5414

ret = start_block_group_remapping(fs_info, path, bg);

fs/btrfs/relocation.c

5418

ret = do_remap_reloc(fs_info, path, rc->block_group);

fs/btrfs/relocation.c

5422

btrfs_delete_unused_bgs(fs_info);

fs/btrfs/relocation.c

5424

ret = do_nonremap_reloc(fs_info, verbose, rc);

fs/btrfs/relocation.c

5430

if (!btrfs_fs_incompat(fs_info, REMAP_TREE))

fs/btrfs/relocation.c

5433

reloc_chunk_end(fs_info);

fs/btrfs/relocation.c

5442

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

5446

trans = btrfs_start_transaction(fs_info->tree_root, 0);

fs/btrfs/relocation.c

545

spin_unlock(&fs_info->trans_lock);

fs/btrfs/relocation.c

5454

ret = btrfs_update_root(trans, fs_info->tree_root,

fs/btrfs/relocation.c

5469

int btrfs_recover_relocation(struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

5492

ret = btrfs_search_slot(NULL, fs_info->tree_root, &key,

fs/btrfs/relocation.c

5510

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

fs/btrfs/relocation.c

5520

fs_root = btrfs_get_fs_root(fs_info,

fs/btrfs/relocation.c

5545

rc = alloc_reloc_control(fs_info);

fs/btrfs/relocation.c

5551

rc->extent_root = btrfs_extent_root(fs_info, 0);

fs/btrfs/relocation.c

5553

btrfs_err(fs_info, "missing extent root for extent at bytenr 0");

fs/btrfs/relocation.c

5558

ret = reloc_chunk_start(fs_info);

fs/btrfs/relocation.c

556

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

5582

fs_root = btrfs_get_fs_root(fs_info, reloc_root->root_key.offset,

fs/btrfs/relocation.c

559

struct reloc_control *rc = fs_info->reloc_ctl;

fs/btrfs/relocation.c

5623

reloc_chunk_end(fs_info);

fs/btrfs/relocation.c

5631

if (ret == 0 && !btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/relocation.c

5633

fs_root = btrfs_grab_root(fs_info->data_reloc_root);

fs/btrfs/relocation.c

5650

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

fs/btrfs/relocation.c

5652

struct btrfs_root *csum_root = btrfs_csum_root(fs_info, disk_bytenr);

fs/btrfs/relocation.c

5658

btrfs_err(fs_info,

fs/btrfs/relocation.c

5702

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

5709

rc = fs_info->reloc_ctl;

fs/btrfs/relocation.c

5731

btrfs_err(fs_info,

fs/btrfs/relocation.c

5768

struct reloc_control *rc = root->fs_info->reloc_ctl;

fs/btrfs/relocation.c

579

btrfs_backref_panic(fs_info, node->bytenr, -EEXIST);

fs/btrfs/relocation.c

5805

struct reloc_control *rc = root->fs_info->reloc_ctl;

fs/btrfs/relocation.c

5811

rc = root->fs_info->reloc_ctl;

fs/btrfs/relocation.c

5843

u64 btrfs_get_reloc_bg_bytenr(const struct btrfs_fs_info *fs_info)

fs/btrfs/relocation.c

5847

lockdep_assert_held(&fs_info->reloc_mutex);

fs/btrfs/relocation.c

5849

if (fs_info->reloc_ctl && fs_info->reloc_ctl->block_group)

fs/btrfs/relocation.c

5850

logical = fs_info->reloc_ctl->block_group->start;

fs/btrfs/relocation.c

5858

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

586

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

5868

ret = btrfs_insert_empty_item(trans, fs_info->remap_root, path,

fs/btrfs/relocation.c

5878

ret = btrfs_insert_empty_item(trans, fs_info->remap_root,

fs/btrfs/relocation.c

5896

ret = btrfs_insert_empty_item(trans, fs_info->remap_root,

fs/btrfs/relocation.c

5924

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

5952

ret = btrfs_del_item(trans, fs_info->remap_root, path);

fs/btrfs/relocation.c

5965

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, -1, 1);

fs/btrfs/relocation.c

5974

ret = btrfs_del_item(trans, fs_info->remap_root, path);

fs/btrfs/relocation.c

6014

dest_bg = btrfs_lookup_block_group(fs_info, new_addr);

fs/btrfs/relocation.c

6040

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/relocation.c

6046

if (!(btrfs_super_incompat_flags(fs_info->super_copy) &

fs/btrfs/relocation.c

6050

bg = btrfs_lookup_block_group(fs_info, bytenr);

fs/btrfs/relocation.c

6054

mutex_lock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

6057

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

6067

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, -1, 1);

fs/btrfs/relocation.c

6106

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/relocation.c

616

btrfs_err(fs_info,

fs/btrfs/relocation.c

672

ret = btrfs_insert_root(trans, fs_info->tree_root,

fs/btrfs/relocation.c

677

reloc_root = btrfs_read_tree_root(fs_info->tree_root, &root_key);

fs/btrfs/relocation.c

701

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

703

struct reloc_control *rc = fs_info->reloc_ctl;

fs/btrfs/relocation.c

767

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

786

if (fs_info->reloc_ctl && fs_info->reloc_ctl->merge_reloc_tree &&

fs/btrfs/relocation.c

804

ret = btrfs_update_root(trans, fs_info->tree_root,

fs/btrfs/relocation.c

860

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/relocation.c

921

fs_info->sectorsize));

fs/btrfs/relocation.c

922

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(const 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

1004

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

1025

u64 mapped_len = fs_info->sectorsize;

fs/btrfs/scrub.c

1032

ret = btrfs_map_block(fs_info, BTRFS_MAP_GET_READ_MIRRORS,

fs/btrfs/scrub.c

1074

btrfs_err_rl(fs_info,

fs/btrfs/scrub.c

1079

btrfs_err_rl(fs_info,

fs/btrfs/scrub.c

1088

btrfs_err_rl(fs_info,

fs/btrfs/scrub.c

1093

btrfs_err_rl(fs_info,

fs/btrfs/scrub.c

1123

i += (fs_info->nodesize >> fs_info->sectorsize_bits))

fs/btrfs/scrub.c

1129

sctx->stat.data_bytes_scrubbed += nr_data_sectors << fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1130

sctx->stat.tree_bytes_scrubbed += nr_meta_sectors << fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1162

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

1164

int num_copies = btrfs_num_copies(fs_info, stripe->bg->start,

fs/btrfs/scrub.c

1221

fs_info->sectorsize, true);

fs/btrfs/scrub.c

1236

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/scrub.c

1237

btrfs_repair_one_zone(fs_info, sctx->stripes[0].bg->start);

fs/btrfs/scrub.c

1261

num_sectors = bio_size >> stripe->bg->fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1273

queue_work(stripe->bg->fs_info->scrub_workers, &stripe->work);

fs/btrfs/scrub.c

1280

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

1294

bio_size >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

1296

for (i = 0; i < (bio_size >> fs_info->sectorsize_bits); i++)

fs/btrfs/scrub.c

1310

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

1318

if (!btrfs_is_zoned(fs_info))

fs/btrfs/scrub.c

1330

if (!test_bit(bio_off >> fs_info->sectorsize_bits,

fs/btrfs/scrub.c

1351

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

1365

bbio = alloc_scrub_bbio(fs_info, stripe->nr_sectors, REQ_OP_WRITE,

fs/btrfs/scrub.c

1366

stripe->logical + (sector_nr << fs_info->sectorsize_bits),

fs/btrfs/scrub.c

1481

struct btrfs_fs_info *fs_info = path->nodes[0]->fs_info;

fs/btrfs/scrub.c

1489

len = fs_info->nodesize;

fs/btrfs/scrub.c

1520

struct btrfs_fs_info *fs_info = extent_root->fs_info;

fs/btrfs/scrub.c

1529

if (btrfs_fs_incompat(fs_info, SKINNY_METADATA))

fs/btrfs/scrub.c

1595

*size_ret = path->nodes[0]->fs_info->nodesize;

fs/btrfs/scrub.c

1606

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

1609

if (!btrfs_is_zoned(fs_info))

fs/btrfs/scrub.c

1618

btrfs_err(fs_info, "scrub: zoned: failed to recover write pointer");

fs/btrfs/scrub.c

1626

static void fill_one_extent_info(struct btrfs_fs_info *fs_info,

fs/btrfs/scrub.c

1634

cur_logical += fs_info->sectorsize) {

fs/btrfs/scrub.c

1636

fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1669

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/scrub.c

1670

struct btrfs_root *extent_root = btrfs_extent_root(fs_info, bg->start);

fs/btrfs/scrub.c

1671

struct btrfs_root *csum_root = btrfs_csum_root(fs_info, bg->start);

fs/btrfs/scrub.c

1682

btrfs_err(fs_info, "scrub: no valid extent or csum root found");

fs/btrfs/scrub.c

1722

fill_one_extent_info(fs_info, stripe, extent_start, extent_len,

fs/btrfs/scrub.c

1742

fill_one_extent_info(fs_info, stripe, extent_start, extent_len,

fs/btrfs/scrub.c

1759

ASSERT(BITS_PER_LONG >= BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

1771

sector_nr * fs_info->csum_size;

fs/btrfs/scrub.c

1803

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

1805

unsigned int nr_sectors = stripe_length(stripe) >> fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1832

(i << fs_info->sectorsize_bits);

fs/btrfs/scrub.c

1836

stripe_len = (nr_sectors - i) << fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1841

ret = btrfs_map_block(fs_info, BTRFS_MAP_READ, logical,

fs/btrfs/scrub.c

1860

bbio = alloc_scrub_bbio(fs_info, stripe->nr_sectors, REQ_OP_READ,

fs/btrfs/scrub.c

1876

queue_work(stripe->bg->fs_info->scrub_workers, &stripe->work);

fs/btrfs/scrub.c

1883

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

1885

const u32 min_folio_shift = PAGE_SHIFT + fs_info->block_min_order;

fs/btrfs/scrub.c

1886

unsigned int nr_sectors = stripe_length(stripe) >> fs_info->sectorsize_bits;

fs/btrfs/scrub.c

1893

if (btrfs_need_stripe_tree_update(fs_info, stripe->bg->flags)) {

fs/btrfs/scrub.c

1898

bbio = alloc_scrub_bbio(fs_info, BTRFS_STRIPE_LEN >> min_folio_shift, REQ_OP_READ,

fs/btrfs/scrub.c

1910

(fs_info->dev_replace.cont_reading_from_srcdev_mode ==

fs/btrfs/scrub.c

1913

int num_copies = btrfs_num_copies(fs_info, stripe->bg->start,

fs/btrfs/scrub.c

1928

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

1930

btrfs_err(fs_info,

fs/btrfs/scrub.c

1933

stripe->logical + (i << fs_info->sectorsize_bits));

fs/btrfs/scrub.c

196

struct btrfs_fs_info *fs_info;

fs/btrfs/scrub.c

1964

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2007

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

fs/btrfs/scrub.c

2086

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2088

if (atomic_read(&fs_info->scrub_cancel_req) ||

fs/btrfs/scrub.c

2110

if (fs_info->sb->s_writers.frozen > SB_UNFROZEN ||

fs/btrfs/scrub.c

2123

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2136

btrfs_bio_counter_inc_blocked(fs_info);

fs/btrfs/scrub.c

2137

ret = btrfs_map_block(fs_info, BTRFS_MAP_WRITE, full_stripe_start,

fs/btrfs/scrub.c

2144

BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

2161

btrfs_bio_counter_dec(fs_info);

fs/btrfs/scrub.c

2172

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2187

if (atomic_read(&fs_info->scrub_pause_req))

fs/btrfs/scrub.c

2188

scrub_blocked_if_needed(fs_info);

fs/btrfs/scrub.c

2262

ASSERT(!btrfs_is_zoned(sctx->fs_info));

fs/btrfs/scrub.c

2286

btrfs_err(fs_info,

fs/btrfs/scrub.c

2315

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2332

if (atomic_read(&fs_info->scrub_pause_req))

fs/btrfs/scrub.c

2333

scrub_blocked_if_needed(fs_info);

fs/btrfs/scrub.c

2444

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2463

scrub_blocked_if_needed(fs_info);

fs/btrfs/scrub.c

2483

ret = init_scrub_stripe(fs_info,

fs/btrfs/scrub.c

2606

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2611

map = btrfs_find_chunk_map(fs_info, bg->start, bg->length);

fs/btrfs/scrub.c

2646

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/scrub.c

2648

if (!btrfs_is_zoned(fs_info))

fs/btrfs/scrub.c

2653

btrfs_wait_ordered_roots(fs_info, U64_MAX, cache);

fs/btrfs/scrub.c

2664

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2665

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/scrub.c

2674

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/scrub.c

2738

cache = btrfs_lookup_block_group(fs_info, chunk_offset);

fs/btrfs/scrub.c

2770

if (sctx->is_dev_replace && btrfs_is_zoned(fs_info)) {

fs/btrfs/scrub.c

2802

scrub_pause_on(fs_info);

fs/btrfs/scrub.c

2839

scrub_pause_off(fs_info);

fs/btrfs/scrub.c

2864

btrfs_warn(fs_info,

fs/btrfs/scrub.c

2867

scrub_pause_off(fs_info);

fs/btrfs/scrub.c

2871

btrfs_warn(fs_info, "scrub: failed setting block group ro: %d",

fs/btrfs/scrub.c

2875

scrub_pause_off(fs_info);

fs/btrfs/scrub.c

2886

btrfs_wait_ordered_roots(fs_info, U64_MAX, cache);

fs/btrfs/scrub.c

2889

scrub_pause_off(fs_info);

fs/btrfs/scrub.c

2922

if (btrfs_test_opt(fs_info, DISCARD_ASYNC))

fs/btrfs/scrub.c

2923

btrfs_discard_queue_work(&fs_info->discard_ctl,

fs/btrfs/scrub.c

2955

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2963

ret = btrfs_check_super_csum(fs_info, sb);

fs/btrfs/scrub.c

2965

btrfs_err_rl(fs_info,

fs/btrfs/scrub.c

2971

btrfs_err_rl(fs_info,

fs/btrfs/scrub.c

2978

return btrfs_validate_super(fs_info, sb, -1);

fs/btrfs/scrub.c

2989

struct btrfs_fs_info *fs_info = sctx->fs_info;

fs/btrfs/scrub.c

2991

if (BTRFS_FS_ERROR(fs_info))

fs/btrfs/scrub.c

3003

if (scrub_dev->fs_devices != fs_info->fs_devices)

fs/btrfs/scrub.c

3006

gen = btrfs_get_last_trans_committed(fs_info);

fs/btrfs/scrub.c

3037

static void scrub_workers_put(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

3039

if (refcount_dec_and_mutex_lock(&fs_info->scrub_workers_refcnt,

fs/btrfs/scrub.c

3040

&fs_info->scrub_lock)) {

fs/btrfs/scrub.c

3041

struct workqueue_struct *scrub_workers = fs_info->scrub_workers;

fs/btrfs/scrub.c

3043

fs_info->scrub_workers = NULL;

fs/btrfs/scrub.c

3044

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3054

static noinline_for_stack int scrub_workers_get(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

3058

int max_active = fs_info->thread_pool_size;

fs/btrfs/scrub.c

3061

if (refcount_inc_not_zero(&fs_info->scrub_workers_refcnt))

fs/btrfs/scrub.c

3068

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3069

if (refcount_read(&fs_info->scrub_workers_refcnt) == 0) {

fs/btrfs/scrub.c

3070

ASSERT(fs_info->scrub_workers == NULL);

fs/btrfs/scrub.c

3071

fs_info->scrub_workers = scrub_workers;

fs/btrfs/scrub.c

3072

refcount_set(&fs_info->scrub_workers_refcnt, 1);

fs/btrfs/scrub.c

3073

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3077

refcount_inc(&fs_info->scrub_workers_refcnt);

fs/btrfs/scrub.c

3078

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3086

int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,

fs/btrfs/scrub.c

3101

if (btrfs_fs_closing(fs_info))

fs/btrfs/scrub.c

3105

ASSERT(fs_info->nodesize <= BTRFS_STRIPE_LEN);

fs/btrfs/scrub.c

3112

ASSERT(fs_info->nodesize <=

fs/btrfs/scrub.c

3113

SCRUB_MAX_SECTORS_PER_BLOCK << fs_info->sectorsize_bits);

fs/btrfs/scrub.c

3116

sctx = scrub_setup_ctx(fs_info, is_dev_replace);

fs/btrfs/scrub.c

3121

ret = scrub_workers_get(fs_info);

fs/btrfs/scrub.c

3125

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

fs/btrfs/scrub.c

3126

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

fs/btrfs/scrub.c

3129

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

fs/btrfs/scrub.c

3136

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

fs/btrfs/scrub.c

3137

btrfs_err(fs_info,

fs/btrfs/scrub.c

3144

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3147

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3148

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

fs/btrfs/scrub.c

3153

down_read(&fs_info->dev_replace.rwsem);

fs/btrfs/scrub.c

3156

btrfs_dev_replace_is_ongoing(&fs_info->dev_replace))) {

fs/btrfs/scrub.c

3157

up_read(&fs_info->dev_replace.rwsem);

fs/btrfs/scrub.c

3158

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3159

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

fs/btrfs/scrub.c

3163

up_read(&fs_info->dev_replace.rwsem);

fs/btrfs/scrub.c

3167

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

fs/btrfs/scrub.c

3173

__scrub_blocked_if_needed(fs_info);

fs/btrfs/scrub.c

3174

atomic_inc(&fs_info->scrubs_running);

fs/btrfs/scrub.c

3175

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3194

btrfs_info(fs_info, "scrub: started on devid %llu", devid);

fs/btrfs/scrub.c

3199

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

fs/btrfs/scrub.c

3201

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

fs/btrfs/scrub.c

3218

atomic_dec(&fs_info->scrubs_running);

fs/btrfs/scrub.c

3219

wake_up(&fs_info->scrub_pause_wait);

fs/btrfs/scrub.c

3225

btrfs_info(fs_info, "scrub: %s on devid %llu with status: %d",

fs/btrfs/scrub.c

3228

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3230

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3232

scrub_workers_put(fs_info);

fs/btrfs/scrub.c

3242

trans = btrfs_start_transaction(fs_info->tree_root, 0);

fs/btrfs/scrub.c

3245

btrfs_err(fs_info,

fs/btrfs/scrub.c

3251

btrfs_err(fs_info,

fs/btrfs/scrub.c

3256

scrub_workers_put(fs_info);

fs/btrfs/scrub.c

3263

void btrfs_scrub_pause(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

3265

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3266

atomic_inc(&fs_info->scrub_pause_req);

fs/btrfs/scrub.c

3267

while (atomic_read(&fs_info->scrubs_paused) !=

fs/btrfs/scrub.c

3268

atomic_read(&fs_info->scrubs_running)) {

fs/btrfs/scrub.c

3269

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3270

wait_event(fs_info->scrub_pause_wait,

fs/btrfs/scrub.c

3271

atomic_read(&fs_info->scrubs_paused) ==

fs/btrfs/scrub.c

3272

atomic_read(&fs_info->scrubs_running));

fs/btrfs/scrub.c

3273

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3275

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3278

void btrfs_scrub_continue(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

3280

atomic_dec(&fs_info->scrub_pause_req);

fs/btrfs/scrub.c

3281

wake_up(&fs_info->scrub_pause_wait);

fs/btrfs/scrub.c

3284

int btrfs_scrub_cancel(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

3286

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3287

if (!atomic_read(&fs_info->scrubs_running)) {

fs/btrfs/scrub.c

3288

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3292

atomic_inc(&fs_info->scrub_cancel_req);

fs/btrfs/scrub.c

3293

while (atomic_read(&fs_info->scrubs_running)) {

fs/btrfs/scrub.c

3294

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3295

wait_event(fs_info->scrub_pause_wait,

fs/btrfs/scrub.c

3296

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

fs/btrfs/scrub.c

3297

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3299

atomic_dec(&fs_info->scrub_cancel_req);

fs/btrfs/scrub.c

3300

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3307

struct btrfs_fs_info *fs_info = dev->fs_info;

fs/btrfs/scrub.c

3310

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3313

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3318

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3319

wait_event(fs_info->scrub_pause_wait,

fs/btrfs/scrub.c

3321

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3323

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

3328

int btrfs_scrub_progress(struct btrfs_fs_info *fs_info, u64 devid,

fs/btrfs/scrub.c

3335

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

fs/btrfs/scrub.c

3336

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

fs/btrfs/scrub.c

3341

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

381

stripe->csums = kcalloc(BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits,

fs/btrfs/scrub.c

382

fs_info->csum_size, GFP_KERNEL);

fs/btrfs/scrub.c

398

static void __scrub_blocked_if_needed(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

400

while (atomic_read(&fs_info->scrub_pause_req)) {

fs/btrfs/scrub.c

401

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

402

wait_event(fs_info->scrub_pause_wait,

fs/btrfs/scrub.c

403

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

fs/btrfs/scrub.c

404

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

408

static void scrub_pause_on(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

410

atomic_inc(&fs_info->scrubs_paused);

fs/btrfs/scrub.c

411

wake_up(&fs_info->scrub_pause_wait);

fs/btrfs/scrub.c

414

static void scrub_pause_off(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

416

mutex_lock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

417

__scrub_blocked_if_needed(fs_info);

fs/btrfs/scrub.c

418

atomic_dec(&fs_info->scrubs_paused);

fs/btrfs/scrub.c

419

mutex_unlock(&fs_info->scrub_lock);

fs/btrfs/scrub.c

421

wake_up(&fs_info->scrub_pause_wait);

fs/btrfs/scrub.c

424

static void scrub_blocked_if_needed(struct btrfs_fs_info *fs_info)

fs/btrfs/scrub.c

426

scrub_pause_on(fs_info);

fs/btrfs/scrub.c

427

scrub_pause_off(fs_info);

fs/btrfs/scrub.c

450

struct btrfs_fs_info *fs_info, bool is_dev_replace)

fs/btrfs/scrub.c

463

sctx->fs_info = fs_info;

fs/btrfs/scrub.c

471

ret = init_scrub_stripe(fs_info, &sctx->stripes[i]);

fs/btrfs/scrub.c

484

WARN_ON(!fs_info->dev_replace.tgtdev);

fs/btrfs/scrub.c

485

sctx->wr_tgtdev = fs_info->dev_replace.tgtdev;

fs/btrfs/scrub.c

505

struct btrfs_fs_info *fs_info = swarn->dev->fs_info;

fs/btrfs/scrub.c

510

local_root = btrfs_get_fs_root(fs_info, root, true);

fs/btrfs/scrub.c

560

btrfs_warn(fs_info,

fs/btrfs/scrub.c

566

fs_info->sectorsize, nlink,

fs/btrfs/scrub.c

573

btrfs_warn(fs_info,

fs/btrfs/scrub.c

586

struct btrfs_fs_info *fs_info = dev->fs_info;

fs/btrfs/scrub.c

598

btrfs_warn(fs_info, "scrub: %s on device %s, physical %llu",

fs/btrfs/scrub.c

611

ret = extent_from_logical(fs_info, swarn.logical, path, &found_key,

fs/btrfs/scrub.c

632

btrfs_warn(fs_info,

fs/btrfs/scrub.c

639

btrfs_warn(fs_info,

fs/btrfs/scrub.c

653

ctx.fs_info = fs_info;

fs/btrfs/scrub.c

667

if (!btrfs_is_zoned(sctx->fs_info))

fs/btrfs/scrub.c

686

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

687

const u32 min_folio_shift = PAGE_SHIFT + fs_info->block_min_order;

fs/btrfs/scrub.c

688

u32 offset = (sector_nr << fs_info->sectorsize_bits);

fs/btrfs/scrub.c

699

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

700

const u32 min_folio_shift = PAGE_SHIFT + fs_info->block_min_order;

fs/btrfs/scrub.c

701

u32 offset = (sector_nr << fs_info->sectorsize_bits);

fs/btrfs/scrub.c

708

ASSERT(offset_in_folio(folio, offset) + fs_info->sectorsize <= folio_size(folio));

fs/btrfs/scrub.c

714

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

715

const u32 sectors_per_tree = fs_info->nodesize >> fs_info->sectorsize_bits;

fs/btrfs/scrub.c

716

const u64 logical = stripe->logical + (sector_nr << fs_info->sectorsize_bits);

fs/btrfs/scrub.c

728

memcpy(on_disk_csum, header->csum, fs_info->csum_size);

fs/btrfs/scrub.c

733

btrfs_warn_rl(fs_info,

fs/btrfs/scrub.c

739

if (memcmp(header->fsid, fs_info->fs_devices->metadata_uuid,

fs/btrfs/scrub.c

743

btrfs_warn_rl(fs_info,

fs/btrfs/scrub.c

746

header->fsid, fs_info->fs_devices->metadata_uuid);

fs/btrfs/scrub.c

749

if (memcmp(header->chunk_tree_uuid, fs_info->chunk_tree_uuid,

fs/btrfs/scrub.c

753

btrfs_warn_rl(fs_info,

fs/btrfs/scrub.c

756

header->chunk_tree_uuid, fs_info->chunk_tree_uuid);

fs/btrfs/scrub.c

761

btrfs_csum_init(&csum, fs_info->csum_type);

fs/btrfs/scrub.c

763

fs_info->sectorsize - BTRFS_CSUM_SIZE);

fs/btrfs/scrub.c

767

fs_info->sectorsize);

fs/btrfs/scrub.c

771

if (memcmp(calculated_csum, on_disk_csum, fs_info->csum_size) != 0) {

fs/btrfs/scrub.c

774

btrfs_warn_rl(fs_info,

fs/btrfs/scrub.c

777

BTRFS_CSUM_FMT_VALUE(fs_info->csum_size, on_disk_csum),

fs/btrfs/scrub.c

778

BTRFS_CSUM_FMT_VALUE(fs_info->csum_size, calculated_csum));

fs/btrfs/scrub.c

785

btrfs_warn_rl(fs_info,

fs/btrfs/scrub.c

800

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

802

const u32 sectors_per_tree = fs_info->nodesize >> fs_info->sectorsize_bits;

fs/btrfs/scrub.c

828

btrfs_warn_rl(fs_info,

fs/btrfs/scrub.c

831

(sector_nr << fs_info->sectorsize_bits),

fs/btrfs/scrub.c

848

ret = btrfs_check_block_csum(fs_info, paddr, csum_buf, sector->csum);

fs/btrfs/scrub.c

861

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

862

const u32 sectors_per_tree = fs_info->nodesize >> fs_info->sectorsize_bits;

fs/btrfs/scrub.c

893

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

906

bio_size >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

908

bio_size >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

911

bio_size >> fs_info->sectorsize_bits);

fs/btrfs/scrub.c

927

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

fs/btrfs/scrub.c

931

ret = bio_add_page(&bbio->bio, virt_to_page(kaddr), fs_info->sectorsize,

fs/btrfs/scrub.c

941

ASSERT(ret == fs_info->sectorsize);

fs/btrfs/scrub.c

944

static struct btrfs_bio *alloc_scrub_bbio(struct btrfs_fs_info *fs_info,

fs/btrfs/scrub.c

951

bbio = btrfs_bio_alloc(nr_vecs, opf, BTRFS_I(fs_info->btree_inode),

fs/btrfs/scrub.c

961

struct btrfs_fs_info *fs_info = stripe->bg->fs_info;

fs/btrfs/scrub.c

983

bbio = alloc_scrub_bbio(fs_info, stripe->nr_sectors, REQ_OP_READ,

fs/btrfs/scrub.c

984

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

1056

btrfs_err(root->fs_info,

fs/btrfs/send.c

1143

BTRFS_MAX_XATTR_SIZE(root->fs_info))) {

fs/btrfs/send.c

1381

struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;

fs/btrfs/send.c

1382

const u64 key = leaf_bytenr >> fs_info->nodesize_bits;

fs/btrfs/send.c

1400

if (fs_info->last_reloc_trans > sctx->backref_cache_last_reloc_trans) {

fs/btrfs/send.c

1421

struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;

fs/btrfs/send.c

1437

new_entry->entry.key = leaf_bytenr >> fs_info->nodesize_bits;

fs/btrfs/send.c

1485

sctx->backref_cache_last_reloc_trans = fs_info->last_reloc_trans;

fs/btrfs/send.c

1552

struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;

fs/btrfs/send.c

1624

backref_walk_ctx.fs_info = fs_info;

fs/btrfs/send.c

1647

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

1648

if (fs_info->last_reloc_trans > sctx->last_reloc_trans) {

fs/btrfs/send.c

1661

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

1664

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

1736

btrfs_err(root->fs_info,

fs/btrfs/send.c

1747

btrfs_crit(root->fs_info,

fs/btrfs/send.c

1755

btrfs_crit(root->fs_info,

fs/btrfs/send.c

2477

ret = btrfs_search_slot_for_read(send_root->fs_info->tree_root,

fs/btrfs/send.c

2827

btrfs_warn(sctx->send_root->fs_info, "unexpected inode type %o",

fs/btrfs/send.c

398

btrfs_err(sctx->send_root->fs_info,

fs/btrfs/send.c

4162

struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;

fs/btrfs/send.c

4183

btrfs_err(fs_info,

fs/btrfs/send.c

4809

btrfs_err(sctx->send_root->fs_info,

fs/btrfs/send.c

5201

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/send.c

5242

btrfs_err(fs_info,

fs/btrfs/send.c

5480

struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;

fs/btrfs/send.c

5508

ret = btrfs_encoded_io_compression_from_extent(fs_info,

fs/btrfs/send.c

5531

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/send.c

5571

ret = btrfs_encoded_io_compression_from_extent(fs_info,

fs/btrfs/send.c

5814

len == sctx->send_root->fs_info->sectorsize)

fs/btrfs/send.c

6063

u64 bs = sctx->send_root->fs_info->sectorsize;

fs/btrfs/send.c

7165

lockdep_assert_not_held(&sctx->send_root->fs_info->commit_root_sem);

fs/btrfs/send.c

7239

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

fs/btrfs/send.c

7252

btrfs_err(root->fs_info,

fs/btrfs/send.c

7269

struct btrfs_fs_info *fs_info = send_root->fs_info;

fs/btrfs/send.c

7281

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7282

sctx->last_reloc_trans = fs_info->last_reloc_trans;

fs/btrfs/send.c

7283

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7299

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7300

if (fs_info->last_reloc_trans > sctx->last_reloc_trans) {

fs/btrfs/send.c

7301

sctx->last_reloc_trans = fs_info->last_reloc_trans;

fs/btrfs/send.c

7302

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7318

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7357

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

fs/btrfs/send.c

7370

reada_max = (*level == 1 ? SZ_128K : eb->fs_info->nodesize);

fs/btrfs/send.c

7375

reada_done += eb->fs_info->nodesize;

fs/btrfs/send.c

7506

lockdep_assert_held_read(&sctx->send_root->fs_info->commit_root_sem);

fs/btrfs/send.c

7583

struct btrfs_fs_info *fs_info = left_root->fs_info;

fs/btrfs/send.c

7616

tmp_buf = kvmalloc(fs_info->nodesize, GFP_KERNEL);

fs/btrfs/send.c

7663

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7710

sctx->last_reloc_trans = fs_info->last_reloc_trans;

fs/btrfs/send.c

7714

rwsem_is_contended(&fs_info->commit_root_sem)) {

fs/btrfs/send.c

7715

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7717

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7720

if (fs_info->last_reloc_trans > sctx->last_reloc_trans) {

fs/btrfs/send.c

7727

sctx->last_reloc_trans = fs_info->last_reloc_trans;

fs/btrfs/send.c

7758

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7765

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7771

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7778

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7785

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7817

down_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

782

btrfs_err(sctx->send_root->fs_info,

fs/btrfs/send.c

7858

up_read(&fs_info->commit_root_sem);

fs/btrfs/send.c

7966

btrfs_err(root->fs_info,

fs/btrfs/send.c

7974

btrfs_warn_rl(root->fs_info,

fs/btrfs/send.c

7982

struct btrfs_fs_info *fs_info = send_root->fs_info;

fs/btrfs/send.c

8144

clone_root = btrfs_get_fs_root(fs_info,

fs/btrfs/send.c

8176

sctx->parent_root = btrfs_get_fs_root(fs_info, arg->parent_root,

fs/btrfs/space-info.c

1060

ordered = percpu_counter_read_positive(&fs_info->ordered_bytes) >> 1;

fs/btrfs/space-info.c

1061

delalloc = percpu_counter_read_positive(&fs_info->delalloc_bytes);

fs/btrfs/space-info.c

1063

used += btrfs_block_rsv_reserved(&fs_info->delayed_refs_rsv) +

fs/btrfs/space-info.c

1064

btrfs_block_rsv_reserved(&fs_info->delayed_block_rsv);

fs/btrfs/space-info.c

1068

return (used >= thresh && !btrfs_fs_closing(fs_info) &&

fs/btrfs/space-info.c

1069

!test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state));

fs/btrfs/space-info.c

1075

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1076

struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;

fs/btrfs/space-info.c

1121

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1124

const int abort_error = BTRFS_FS_ERROR(fs_info);

fs/btrfs/space-info.c

1126

trace_btrfs_fail_all_tickets(fs_info, space_info);

fs/btrfs/space-info.c

1128

if (btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {

fs/btrfs/space-info.c

1129

btrfs_info(fs_info, "cannot satisfy tickets, dumping space info");

fs/btrfs/space-info.c

1143

if (btrfs_test_opt(fs_info, ENOSPC_DEBUG))

fs/btrfs/space-info.c

1144

btrfs_info(fs_info, "failing ticket with %llu bytes",

fs/btrfs/space-info.c

1163

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1170

if (btrfs_is_zoned(fs_info))

fs/btrfs/space-info.c

1249

struct btrfs_fs_info *fs_info;

fs/btrfs/space-info.c

1252

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

fs/btrfs/space-info.c

1253

space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);

fs/btrfs/space-info.c

1271

struct btrfs_fs_info *fs_info;

fs/btrfs/space-info.c

1279

fs_info = container_of(work, struct btrfs_fs_info,

fs/btrfs/space-info.c

1281

space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);

fs/btrfs/space-info.c

1282

delayed_block_rsv = &fs_info->delayed_block_rsv;

fs/btrfs/space-info.c

1283

delayed_refs_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/space-info.c

1284

global_rsv = &fs_info->global_block_rsv;

fs/btrfs/space-info.c

1285

trans_rsv = &fs_info->trans_block_rsv;

fs/btrfs/space-info.c

1349

to_reclaim = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/space-info.c

1358

trace_btrfs_done_preemptive_reclaim(fs_info, space_info);

fs/btrfs/space-info.c

1409

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1432

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/space-info.c

1466

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/space-info.c

1482

struct btrfs_fs_info *fs_info;

fs/btrfs/space-info.c

1485

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

fs/btrfs/space-info.c

1486

space_info = fs_info->data_sinfo;

fs/btrfs/space-info.c

1493

void btrfs_init_async_reclaim_work(struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

1495

INIT_WORK(&fs_info->async_reclaim_work, btrfs_async_reclaim_metadata_space);

fs/btrfs/space-info.c

1496

INIT_WORK(&fs_info->async_data_reclaim_work, btrfs_async_reclaim_data_space);

fs/btrfs/space-info.c

1497

INIT_WORK(&fs_info->preempt_reclaim_work,

fs/btrfs/space-info.c

1537

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1570

if (unlikely(BTRFS_FS_ERROR(fs_info)))

fs/btrfs/space-info.c

1571

remove_ticket(space_info, ticket, BTRFS_FS_ERROR(fs_info));

fs/btrfs/space-info.c

1693

trace_btrfs_reserve_ticket(space_info->fs_info, space_info->flags,

fs/btrfs/space-info.c

1710

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1711

u64 ordered = percpu_counter_sum_positive(&fs_info->ordered_bytes);

fs/btrfs/space-info.c

1712

u64 delalloc = percpu_counter_sum_positive(&fs_info->delalloc_bytes);

fs/btrfs/space-info.c

1759

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1782

async_work = &fs_info->async_data_reclaim_work;

fs/btrfs/space-info.c

1784

async_work = &fs_info->async_reclaim_work;

fs/btrfs/space-info.c

1856

trace_btrfs_trigger_flush(fs_info,

fs/btrfs/space-info.c

1872

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

fs/btrfs/space-info.c

1873

!work_busy(&fs_info->preempt_reclaim_work) &&

fs/btrfs/space-info.c

1875

trace_btrfs_trigger_flush(fs_info, space_info->flags,

fs/btrfs/space-info.c

1878

&fs_info->preempt_reclaim_work);

fs/btrfs/space-info.c

1910

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1912

trace_btrfs_space_reservation(fs_info, "space_info:enospc",

fs/btrfs/space-info.c

1915

if (btrfs_test_opt(fs_info, ENOSPC_DEBUG))

fs/btrfs/space-info.c

1934

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

1946

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

1955

__cold void btrfs_dump_space_info_for_trans_abort(struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

1959

btrfs_info(fs_info, "dumping space info:");

fs/btrfs/space-info.c

1960

list_for_each_entry(space_info, &fs_info->space_info, list) {

fs/btrfs/space-info.c

1965

dump_global_block_rsv(fs_info);

fs/btrfs/space-info.c

2028

static u64 calc_unalloc_target(struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

2030

u64 chunk_sz = calc_effective_data_chunk_size(fs_info);

fs/btrfs/space-info.c

2060

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

2061

u64 unalloc = atomic64_read(&fs_info->free_chunk_space);

fs/btrfs/space-info.c

2062

u64 target = calc_unalloc_target(fs_info);

fs/btrfs/space-info.c

2067

u64 data_chunk_size = calc_effective_data_chunk_size(fs_info);

fs/btrfs/space-info.c

209

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

fs/btrfs/space-info.c

2093

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

2094

u64 unalloc = atomic64_read(&fs_info->free_chunk_space);

fs/btrfs/space-info.c

2095

u64 data_chunk_size = calc_effective_data_chunk_size(fs_info);

fs/btrfs/space-info.c

211

if (btrfs_is_zoned(fs_info))

fs/btrfs/space-info.c

212

return fs_info->zone_size;

fs/btrfs/space-info.c

2150

u64 chunk_sz = calc_effective_data_chunk_size(space_info->fs_info);

fs/btrfs/space-info.c

2188

void btrfs_reclaim_sweep(const struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

2193

list_for_each_entry(space_info, &fs_info->space_info, list) {

fs/btrfs/space-info.c

2208

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

2209

struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;

fs/btrfs/space-info.c

222

if (fs_info->fs_devices->total_rw_bytes > 50ULL * SZ_1G)

fs/btrfs/space-info.c

240

space_info->fs_info = info;

fs/btrfs/space-info.c

261

struct btrfs_fs_info *fs_info = parent->fs_info;

fs/btrfs/space-info.c

273

init_space_info(fs_info, sub_group, flags);

fs/btrfs/space-info.c

327

int btrfs_init_space_info(struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

335

disk_super = fs_info->super_copy;

fs/btrfs/space-info.c

344

ret = create_space_info(fs_info, flags);

fs/btrfs/space-info.c

350

ret = create_space_info(fs_info, flags);

fs/btrfs/space-info.c

355

ret = create_space_info(fs_info, flags);

fs/btrfs/space-info.c

360

ret = create_space_info(fs_info, flags);

fs/btrfs/space-info.c

367

ret = create_space_info(fs_info, flags);

fs/btrfs/space-info.c

421

static u64 calc_effective_data_chunk_size(struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

435

data_sinfo = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_DATA);

fs/btrfs/space-info.c

436

if (btrfs_is_zoned(fs_info))

fs/btrfs/space-info.c

439

mult_perc(fs_info->fs_devices->total_rw_bytes, 10));

fs/btrfs/space-info.c

446

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

453

profile = btrfs_system_alloc_profile(fs_info);

fs/btrfs/space-info.c

455

profile = btrfs_metadata_alloc_profile(fs_info);

fs/btrfs/space-info.c

457

avail = atomic64_read(&fs_info->free_chunk_space);

fs/btrfs/space-info.c

470

data_chunk_size = calc_effective_data_chunk_size(fs_info);

fs/btrfs/space-info.c

506

if (btrfs_is_zoned(fs_info))

fs/btrfs/space-info.c

507

avail = ALIGN_DOWN(avail, fs_info->zone_size);

fs/btrfs/space-info.c

614

#define DUMP_BLOCK_RSV(fs_info, rsv_name) \

fs/btrfs/space-info.c

616

struct btrfs_block_rsv *__rsv = &(fs_info)->rsv_name; \

fs/btrfs/space-info.c

618

btrfs_info(fs_info, #rsv_name ": size %llu reserved %llu", \

fs/btrfs/space-info.c

623

static void dump_global_block_rsv(struct btrfs_fs_info *fs_info)

fs/btrfs/space-info.c

625

DUMP_BLOCK_RSV(fs_info, global_block_rsv);

fs/btrfs/space-info.c

626

DUMP_BLOCK_RSV(fs_info, trans_block_rsv);

fs/btrfs/space-info.c

627

DUMP_BLOCK_RSV(fs_info, chunk_block_rsv);

fs/btrfs/space-info.c

628

DUMP_BLOCK_RSV(fs_info, remap_block_rsv);

fs/btrfs/space-info.c

629

DUMP_BLOCK_RSV(fs_info, delayed_block_rsv);

fs/btrfs/space-info.c

630

DUMP_BLOCK_RSV(fs_info, delayed_refs_rsv);

fs/btrfs/space-info.c

635

const struct btrfs_fs_info *fs_info = info->fs_info;

fs/btrfs/space-info.c

640

btrfs_info(fs_info,

fs/btrfs/space-info.c

645

btrfs_info(fs_info,

fs/btrfs/space-info.c

655

struct btrfs_fs_info *fs_info = info->fs_info;

fs/btrfs/space-info.c

662

dump_global_block_rsv(fs_info);

fs/btrfs/space-info.c

675

btrfs_info(fs_info,

fs/btrfs/space-info.c

689

btrfs_info(fs_info, "%llu bytes available across all block groups", total_avail);

fs/btrfs/space-info.c

692

static inline u64 calc_reclaim_items_nr(const struct btrfs_fs_info *fs_info,

fs/btrfs/space-info.c

698

bytes = btrfs_calc_insert_metadata_size(fs_info, 1);

fs/btrfs/space-info.c

712

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

720

delalloc_bytes = percpu_counter_sum_positive(&fs_info->delalloc_bytes);

fs/btrfs/space-info.c

721

ordered_bytes = percpu_counter_sum_positive(&fs_info->ordered_bytes);

fs/btrfs/space-info.c

742

items = calc_reclaim_items_nr(fs_info, to_reclaim) * 2;

fs/btrfs/space-info.c

761

btrfs_start_delalloc_roots(fs_info, nr_pages, true);

fs/btrfs/space-info.c

784

async_pages = atomic_read(&fs_info->async_delalloc_pages);

fs/btrfs/space-info.c

798

wait_event(fs_info->async_submit_wait,

fs/btrfs/space-info.c

799

atomic_read(&fs_info->async_delalloc_pages) <=

fs/btrfs/space-info.c

804

btrfs_wait_ordered_roots(fs_info, items, NULL);

fs/btrfs/space-info.c

828

&fs_info->delalloc_bytes);

fs/btrfs/space-info.c

830

&fs_info->ordered_bytes);

fs/btrfs/space-info.c

842

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

843

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/space-info.c

852

nr = calc_reclaim_items_nr(fs_info, num_bytes) * 2;

fs/btrfs/space-info.c

897

btrfs_get_alloc_profile(fs_info, space_info->flags),

fs/btrfs/space-info.c

911

btrfs_run_delayed_iputs(fs_info);

fs/btrfs/space-info.c

912

btrfs_wait_on_delayed_iputs(fs_info);

fs/btrfs/space-info.c

933

trace_btrfs_flush_space(fs_info, space_info->flags, num_bytes, state,

fs/btrfs/space-info.c

963

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/space-info.c

964

const u64 global_rsv_size = btrfs_block_rsv_reserved(&fs_info->global_block_rsv);

fs/btrfs/space-info.h

109

struct btrfs_fs_info *fs_info;

fs/btrfs/space-info.h

242

struct btrfs_fs_info *fs_info = sinfo->fs_info; \

fs/btrfs/space-info.h

245

trace_update_##name(fs_info, sinfo, sinfo->name, bytes); \

fs/btrfs/space-info.h

246

trace_btrfs_space_reservation(fs_info, trace_name, \

fs/btrfs/space-info.h

272

int btrfs_init_space_info(struct btrfs_fs_info *fs_info);

fs/btrfs/space-info.h

300

void btrfs_dump_space_info_for_trans_abort(struct btrfs_fs_info *fs_info);

fs/btrfs/space-info.h

301

void btrfs_init_async_reclaim_work(struct btrfs_fs_info *fs_info);

fs/btrfs/space-info.h

307

void btrfs_reclaim_sweep(const struct btrfs_fs_info *fs_info);

fs/btrfs/subpage.c

106

if (type == BTRFS_SUBPAGE_METADATA && !btrfs_meta_is_subpage(fs_info))

fs/btrfs/subpage.c

108

if (type == BTRFS_SUBPAGE_DATA && !btrfs_is_subpage(fs_info, folio))

fs/btrfs/subpage.c

116

struct btrfs_folio_state *btrfs_alloc_folio_state(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

122

ASSERT(fs_info->sectorsize < fsize);

fs/btrfs/subpage.c

126

(fsize >> fs_info->sectorsize_bits)));

fs/btrfs/subpage.c

148

void btrfs_folio_inc_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio)

fs/btrfs/subpage.c

152

if (!btrfs_meta_is_subpage(fs_info))

fs/btrfs/subpage.c

162

void btrfs_folio_dec_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio)

fs/btrfs/subpage.c

166

if (!btrfs_meta_is_subpage(fs_info))

fs/btrfs/subpage.c

177

static void btrfs_subpage_assert(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

182

ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&

fs/btrfs/subpage.c

183

IS_ALIGNED(len, fs_info->sectorsize), "start=%llu len=%u", start, len);

fs/btrfs/subpage.c

195

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

fs/btrfs/subpage.c

198

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

200

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

fs/btrfs/subpage.c

201

__start_bit = offset_in_folio(folio, start) >> fs_info->sectorsize_bits; \

fs/btrfs/subpage.c

223

static bool btrfs_subpage_end_and_test_lock(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

227

const int start_bit = subpage_calc_start_bit(fs_info, folio, locked, start, len);

fs/btrfs/subpage.c

228

const int nbits = (len >> fs_info->sectorsize_bits);

fs/btrfs/subpage.c

234

btrfs_subpage_assert(fs_info, folio, start, len);

fs/btrfs/subpage.c

277

void btrfs_folio_end_lock(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

284

if (unlikely(!fs_info) || !btrfs_is_subpage(fs_info, folio)) {

fs/btrfs/subpage.c

303

if (btrfs_subpage_end_and_test_lock(fs_info, folio, start, len))

fs/btrfs/subpage.c

307

void btrfs_folio_end_lock_bitmap(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

311

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

fs/btrfs/subpage.c

318

if (!btrfs_is_subpage(fs_info, folio)) {

fs/btrfs/subpage.c

343

#define subpage_test_bitmap_all_set(fs_info, folio, name) \

fs/btrfs/subpage.c

346

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

352

#define subpage_test_bitmap_all_zero(fs_info, folio, name) \

fs/btrfs/subpage.c

355

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

361

void btrfs_subpage_set_uptodate(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

365

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

370

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

fs/btrfs/subpage.c

371

if (subpage_test_bitmap_all_set(fs_info, folio, uptodate))

fs/btrfs/subpage.c

376

void btrfs_subpage_clear_uptodate(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

380

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

385

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

fs/btrfs/subpage.c

390

void btrfs_subpage_set_dirty(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

394

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

399

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

fs/btrfs/subpage.c

414

bool btrfs_subpage_clear_and_test_dirty(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

418

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

424

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

fs/btrfs/subpage.c

425

if (subpage_test_bitmap_all_zero(fs_info, folio, dirty))

fs/btrfs/subpage.c

431

void btrfs_subpage_clear_dirty(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

436

last = btrfs_subpage_clear_and_test_dirty(fs_info, folio, start, len);

fs/btrfs/subpage.c

441

void btrfs_subpage_set_writeback(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

445

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

451

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

fs/btrfs/subpage.c

465

void btrfs_subpage_clear_writeback(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

474

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

fs/btrfs/subpage.c

475

if (subpage_test_bitmap_all_zero(fs_info, folio, writeback)) {

fs/btrfs/subpage.c

482

void btrfs_subpage_set_ordered(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

486

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

491

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

fs/btrfs/subpage.c

496

void btrfs_subpage_clear_ordered(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

500

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

505

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

fs/btrfs/subpage.c

506

if (subpage_test_bitmap_all_zero(fs_info, folio, ordered))

fs/btrfs/subpage.c

511

void btrfs_subpage_set_checked(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

515

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

520

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

fs/btrfs/subpage.c

521

if (subpage_test_bitmap_all_set(fs_info, folio, checked))

fs/btrfs/subpage.c

526

void btrfs_subpage_clear_checked(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

530

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

535

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

fs/btrfs/subpage.c

545

bool btrfs_subpage_test_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

549

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio, \

fs/btrfs/subpage.c

556

len >> fs_info->sectorsize_bits); \

fs/btrfs/subpage.c

573

void btrfs_folio_set_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

576

if (unlikely(!fs_info) || \

fs/btrfs/subpage.c

577

!btrfs_is_subpage(fs_info, folio)) { \

fs/btrfs/subpage.c

581

btrfs_subpage_set_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

583

void btrfs_folio_clear_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

586

if (unlikely(!fs_info) || \

fs/btrfs/subpage.c

587

!btrfs_is_subpage(fs_info, folio)) { \

fs/btrfs/subpage.c

591

btrfs_subpage_clear_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

593

bool btrfs_folio_test_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

596

if (unlikely(!fs_info) || \

fs/btrfs/subpage.c

597

!btrfs_is_subpage(fs_info, folio)) \

fs/btrfs/subpage.c

599

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

fs/btrfs/subpage.c

601

void btrfs_folio_clamp_set_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

604

if (unlikely(!fs_info) || \

fs/btrfs/subpage.c

605

!btrfs_is_subpage(fs_info, folio)) { \

fs/btrfs/subpage.c

610

btrfs_subpage_set_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

612

void btrfs_folio_clamp_clear_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

615

if (unlikely(!fs_info) || \

fs/btrfs/subpage.c

616

!btrfs_is_subpage(fs_info, folio)) { \

fs/btrfs/subpage.c

621

btrfs_subpage_clear_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

623

bool btrfs_folio_clamp_test_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.c

626

if (unlikely(!fs_info) || \

fs/btrfs/subpage.c

627

!btrfs_is_subpage(fs_info, folio)) \

fs/btrfs/subpage.c

630

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

fs/btrfs/subpage.c

634

if (!btrfs_meta_is_subpage(eb->fs_info)) { \

fs/btrfs/subpage.c

638

btrfs_subpage_set_##name(eb->fs_info, folio, eb->start, eb->len); \

fs/btrfs/subpage.c

642

if (!btrfs_meta_is_subpage(eb->fs_info)) { \

fs/btrfs/subpage.c

646

btrfs_subpage_clear_##name(eb->fs_info, folio, eb->start, eb->len); \

fs/btrfs/subpage.c

650

if (!btrfs_meta_is_subpage(eb->fs_info)) \

fs/btrfs/subpage.c

652

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

fs/btrfs/subpage.c

66

int btrfs_attach_folio_state(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

665

#define GET_SUBPAGE_BITMAP(fs_info, folio, name, dst) \

fs/btrfs/subpage.c

667

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

675

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

fs/btrfs/subpage.c

678

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

680

GET_SUBPAGE_BITMAP(fs_info, folio, name, &bitmap); \

fs/btrfs/subpage.c

681

btrfs_warn(fs_info, \

fs/btrfs/subpage.c

690

void btrfs_folio_assert_not_dirty(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

701

if (!btrfs_is_subpage(fs_info, folio)) {

fs/btrfs/subpage.c

706

start_bit = subpage_calc_start_bit(fs_info, folio, dirty, start, len);

fs/btrfs/subpage.c

707

nbits = len >> fs_info->sectorsize_bits;

fs/btrfs/subpage.c

712

SUBPAGE_DUMP_BITMAP(fs_info, folio, dirty, start, len);

fs/btrfs/subpage.c

726

void btrfs_folio_set_lock(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

736

if (unlikely(!fs_info) || !btrfs_is_subpage(fs_info, folio))

fs/btrfs/subpage.c

740

start_bit = subpage_calc_start_bit(fs_info, folio, locked, start, len);

fs/btrfs/subpage.c

741

nbits = len >> fs_info->sectorsize_bits;

fs/btrfs/subpage.c

745

SUBPAGE_DUMP_BITMAP(fs_info, folio, locked, start, len);

fs/btrfs/subpage.c

750

ASSERT(ret <= btrfs_blocks_per_folio(fs_info, folio));

fs/btrfs/subpage.c

763

if (!btrfs_meta_is_subpage(eb->fs_info)) {

fs/btrfs/subpage.c

768

last = btrfs_subpage_clear_and_test_dirty(eb->fs_info, folio, eb->start, eb->len);

fs/btrfs/subpage.c

776

void __cold btrfs_subpage_dump_bitmap(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

780

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

fs/btrfs/subpage.c

794

GET_SUBPAGE_BITMAP(fs_info, folio, uptodate, &uptodate_bitmap);

fs/btrfs/subpage.c

795

GET_SUBPAGE_BITMAP(fs_info, folio, dirty, &dirty_bitmap);

fs/btrfs/subpage.c

796

GET_SUBPAGE_BITMAP(fs_info, folio, writeback, &writeback_bitmap);

fs/btrfs/subpage.c

797

GET_SUBPAGE_BITMAP(fs_info, folio, ordered, &ordered_bitmap);

fs/btrfs/subpage.c

798

GET_SUBPAGE_BITMAP(fs_info, folio, checked, &checked_bitmap);

fs/btrfs/subpage.c

799

GET_SUBPAGE_BITMAP(fs_info, folio, locked, &locked_bitmap);

fs/btrfs/subpage.c

803

btrfs_warn(fs_info,

fs/btrfs/subpage.c

814

void btrfs_get_subpage_dirty_bitmap(struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.c

822

ASSERT(btrfs_blocks_per_folio(fs_info, folio) > 1);

fs/btrfs/subpage.c

826

GET_SUBPAGE_BITMAP(fs_info, folio, dirty, ret_bitmap);

fs/btrfs/subpage.c

85

if (type == BTRFS_SUBPAGE_METADATA && !btrfs_meta_is_subpage(fs_info))

fs/btrfs/subpage.c

87

if (type == BTRFS_SUBPAGE_DATA && !btrfs_is_subpage(fs_info, folio))

fs/btrfs/subpage.c

90

bfs = btrfs_alloc_folio_state(fs_info, folio_size(folio), type);

fs/btrfs/subpage.c

98

void btrfs_detach_folio_state(const struct btrfs_fs_info *fs_info, struct folio *folio,

fs/btrfs/subpage.h

103

static inline bool btrfs_meta_is_subpage(const struct btrfs_fs_info *fs_info)

fs/btrfs/subpage.h

105

return fs_info->nodesize < PAGE_SIZE;

fs/btrfs/subpage.h

107

static inline bool btrfs_is_subpage(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

112

return fs_info->sectorsize < folio_size(folio);

fs/btrfs/subpage.h

115

int btrfs_attach_folio_state(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

117

void btrfs_detach_folio_state(const struct btrfs_fs_info *fs_info, struct folio *folio,

fs/btrfs/subpage.h

121

struct btrfs_folio_state *btrfs_alloc_folio_state(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

128

void btrfs_folio_inc_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio);

fs/btrfs/subpage.h

129

void btrfs_folio_dec_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio);

fs/btrfs/subpage.h

131

void btrfs_folio_end_lock(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

133

void btrfs_folio_set_lock(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

135

void btrfs_folio_end_lock_bitmap(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

159

void btrfs_subpage_set_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

161

void btrfs_subpage_clear_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

163

bool btrfs_subpage_test_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

165

void btrfs_folio_set_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

167

void btrfs_folio_clear_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

169

bool btrfs_folio_test_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

171

void btrfs_folio_clamp_set_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

173

void btrfs_folio_clamp_clear_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

175

bool btrfs_folio_clamp_test_##name(const struct btrfs_fs_info *fs_info, \

fs/btrfs/subpage.h

191

static inline void btrfs_folio_clamp_finish_io(struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

195

btrfs_folio_clamp_clear_dirty(fs_info, locked_folio, start, len);

fs/btrfs/subpage.h

196

btrfs_folio_clamp_set_writeback(fs_info, locked_folio, start, len);

fs/btrfs/subpage.h

197

btrfs_folio_clamp_clear_writeback(fs_info, locked_folio, start, len);

fs/btrfs/subpage.h

200

bool btrfs_subpage_clear_and_test_dirty(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

203

void btrfs_folio_assert_not_dirty(const struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

206

void btrfs_get_subpage_dirty_bitmap(struct btrfs_fs_info *fs_info,

fs/btrfs/subpage.h

209

void __cold btrfs_subpage_dump_bitmap(const struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

1006

close_ctree(fs_info);

fs/btrfs/super.c

1013

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

1014

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/super.c

1016

trace_btrfs_sync_fs(fs_info, wait);

fs/btrfs/super.c

1019

filemap_flush(fs_info->btree_inode->i_mapping);

fs/btrfs/super.c

1023

btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);

fs/btrfs/super.c

1034

&fs_info->flags))

fs/btrfs/super.c

1202

struct btrfs_fs_info *fs_info = btrfs_sb(s);

fs/btrfs/super.c

1208

btrfs_err(fs_info, "'%s' is not a valid subvolume",

fs/btrfs/super.c

1218

btrfs_err(fs_info,

fs/btrfs/super.c

1236

static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

1242

fs_info->thread_pool_size = new_pool_size;

fs/btrfs/super.c

1244

btrfs_info(fs_info, "resize thread pool %d -> %d",

fs/btrfs/super.c

1247

btrfs_workqueue_set_max(fs_info->workers, new_pool_size);

fs/btrfs/super.c

1248

btrfs_workqueue_set_max(fs_info->delalloc_workers, new_pool_size);

fs/btrfs/super.c

1249

btrfs_workqueue_set_max(fs_info->caching_workers, new_pool_size);

fs/btrfs/super.c

1250

workqueue_set_max_active(fs_info->endio_workers, new_pool_size);

fs/btrfs/super.c

1251

workqueue_set_max_active(fs_info->endio_meta_workers, new_pool_size);

fs/btrfs/super.c

1252

btrfs_workqueue_set_max(fs_info->endio_write_workers, new_pool_size);

fs/btrfs/super.c

1253

btrfs_workqueue_set_max(fs_info->endio_freespace_worker, new_pool_size);

fs/btrfs/super.c

1254

btrfs_workqueue_set_max(fs_info->delayed_workers, new_pool_size);

fs/btrfs/super.c

1257

static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

1261

(!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||

fs/btrfs/super.c

1264

wait_event(fs_info->transaction_wait,

fs/btrfs/super.c

1265

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

fs/btrfs/super.c

1267

sync_filesystem(fs_info->sb);

fs/btrfs/super.c

1271

static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

1274

const bool cache_opt = btrfs_test_opt(fs_info, SPACE_CACHE);

fs/btrfs/super.c

1281

(!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) || sb_rdonly(fs_info->sb))) {

fs/btrfs/super.c

1282

btrfs_cleanup_defrag_inodes(fs_info);

fs/btrfs/super.c

1287

btrfs_test_opt(fs_info, DISCARD_ASYNC))

fs/btrfs/super.c

1288

btrfs_discard_resume(fs_info);

fs/btrfs/super.c

1290

!btrfs_test_opt(fs_info, DISCARD_ASYNC))

fs/btrfs/super.c

1291

btrfs_discard_cleanup(fs_info);

fs/btrfs/super.c

1294

if (cache_opt != btrfs_free_space_cache_v1_active(fs_info))

fs/btrfs/super.c

1295

btrfs_set_free_space_cache_v1_active(fs_info, cache_opt);

fs/btrfs/super.c

1298

static int btrfs_remount_rw(struct btrfs_fs_info *fs_info)

fs/btrfs/super.c

1302

if (BTRFS_FS_ERROR(fs_info)) {

fs/btrfs/super.c

1303

btrfs_err(fs_info,

fs/btrfs/super.c

1308

if (fs_info->fs_devices->rw_devices == 0)

fs/btrfs/super.c

1311

if (!btrfs_check_rw_degradable(fs_info, NULL)) {

fs/btrfs/super.c

1312

btrfs_warn(fs_info,

fs/btrfs/super.c

1317

if (btrfs_super_log_root(fs_info->super_copy) != 0) {

fs/btrfs/super.c

1318

btrfs_warn(fs_info,

fs/btrfs/super.c

1328

ret = btrfs_start_pre_rw_mount(fs_info);

fs/btrfs/super.c

1332

btrfs_clear_sb_rdonly(fs_info->sb);

fs/btrfs/super.c

1334

set_bit(BTRFS_FS_OPEN, &fs_info->flags);

fs/btrfs/super.c

1340

btrfs_discard_resume(fs_info);

fs/btrfs/super.c

1345

static int btrfs_remount_ro(struct btrfs_fs_info *fs_info)

fs/btrfs/super.c

1351

cancel_work_sync(&fs_info->async_reclaim_work);

fs/btrfs/super.c

1352

cancel_work_sync(&fs_info->async_data_reclaim_work);

fs/btrfs/super.c

1354

btrfs_discard_cleanup(fs_info);

fs/btrfs/super.c

1357

down(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/super.c

1359

up(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/super.c

1361

btrfs_set_sb_rdonly(fs_info->sb);

fs/btrfs/super.c

1369

btrfs_delete_unused_bgs(fs_info);

fs/btrfs/super.c

1381

wait_on_bit(&fs_info->flags, BTRFS_FS_CLEANER_RUNNING, TASK_UNINTERRUPTIBLE);

fs/btrfs/super.c

1390

btrfs_run_delayed_iputs(fs_info);

fs/btrfs/super.c

1392

btrfs_dev_replace_suspend_for_unmount(fs_info);

fs/btrfs/super.c

1393

btrfs_scrub_cancel(fs_info);

fs/btrfs/super.c

1394

btrfs_pause_balance(fs_info);

fs/btrfs/super.c

1402

btrfs_qgroup_wait_for_completion(fs_info, false);

fs/btrfs/super.c

1404

return btrfs_commit_super(fs_info);

fs/btrfs/super.c

1407

static void btrfs_ctx_to_info(struct btrfs_fs_info *fs_info, struct btrfs_fs_context *ctx)

fs/btrfs/super.c

1409

fs_info->max_inline = ctx->max_inline;

fs/btrfs/super.c

1410

fs_info->commit_interval = ctx->commit_interval;

fs/btrfs/super.c

1411

fs_info->metadata_ratio = ctx->metadata_ratio;

fs/btrfs/super.c

1412

fs_info->thread_pool_size = ctx->thread_pool_size;

fs/btrfs/super.c

1413

fs_info->mount_opt = ctx->mount_opt;

fs/btrfs/super.c

1414

fs_info->compress_type = ctx->compress_type;

fs/btrfs/super.c

1415

fs_info->compress_level = ctx->compress_level;

fs/btrfs/super.c

1418

static void btrfs_info_to_ctx(struct btrfs_fs_info *fs_info, struct btrfs_fs_context *ctx)

fs/btrfs/super.c

1420

ctx->max_inline = fs_info->max_inline;

fs/btrfs/super.c

1421

ctx->commit_interval = fs_info->commit_interval;

fs/btrfs/super.c

1422

ctx->metadata_ratio = fs_info->metadata_ratio;

fs/btrfs/super.c

1423

ctx->thread_pool_size = fs_info->thread_pool_size;

fs/btrfs/super.c

1424

ctx->mount_opt = fs_info->mount_opt;

fs/btrfs/super.c

1425

ctx->compress_type = fs_info->compress_type;

fs/btrfs/super.c

1426

ctx->compress_level = fs_info->compress_level;

fs/btrfs/super.c

1429

#define btrfs_info_if_set(fs_info, old_ctx, opt, fmt, args...) \

fs/btrfs/super.c

1432

btrfs_raw_test_opt(fs_info->mount_opt, opt)) \

fs/btrfs/super.c

1433

btrfs_info(fs_info, fmt, ##args); \

fs/btrfs/super.c

1436

#define btrfs_info_if_unset(fs_info, old_ctx, opt, fmt, args...) \

fs/btrfs/super.c

1439

!btrfs_raw_test_opt(fs_info->mount_opt, opt)) \

fs/btrfs/super.c

1440

btrfs_info(fs_info, fmt, ##args); \

fs/btrfs/super.c

1502

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

1508

btrfs_info_to_ctx(fs_info, &old_ctx);

fs/btrfs/super.c

1519

set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);

fs/btrfs/super.c

1521

if (!btrfs_check_options(fs_info, &ctx->mount_opt, fc->sb_flags))

fs/btrfs/super.c

1524

ret = btrfs_check_features(fs_info, !(fc->sb_flags & SB_RDONLY));

fs/btrfs/super.c

1528

btrfs_ctx_to_info(fs_info, ctx);

fs/btrfs/super.c

1529

btrfs_remount_begin(fs_info, old_ctx.mount_opt, fc->sb_flags);

fs/btrfs/super.c

1530

btrfs_resize_thread_pool(fs_info, fs_info->thread_pool_size,

fs/btrfs/super.c

1533

if ((bool)btrfs_test_opt(fs_info, FREE_SPACE_TREE) !=

fs/btrfs/super.c

1534

(bool)btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&

fs/btrfs/super.c

1536

btrfs_warn(fs_info,

fs/btrfs/super.c

1539

if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {

fs/btrfs/super.c

1540

btrfs_set_opt(fs_info->mount_opt, FREE_SPACE_TREE);

fs/btrfs/super.c

1541

btrfs_clear_opt(fs_info->mount_opt, SPACE_CACHE);

fs/btrfs/super.c

1543

if (btrfs_free_space_cache_v1_active(fs_info)) {

fs/btrfs/super.c

1544

btrfs_clear_opt(fs_info->mount_opt, FREE_SPACE_TREE);

fs/btrfs/super.c

1545

btrfs_set_opt(fs_info->mount_opt, SPACE_CACHE);

fs/btrfs/super.c

1551

ret = btrfs_remount_ro(fs_info);

fs/btrfs/super.c

1553

ret = btrfs_remount_rw(fs_info);

fs/btrfs/super.c

1565

btrfs_emit_options(fs_info, &old_ctx);

fs/btrfs/super.c

1566

wake_up_process(fs_info->transaction_kthread);

fs/btrfs/super.c

1567

btrfs_remount_cleanup(fs_info, old_ctx.mount_opt);

fs/btrfs/super.c

1568

btrfs_clear_oneshot_options(fs_info);

fs/btrfs/super.c

1569

clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);

fs/btrfs/super.c

1573

btrfs_ctx_to_info(fs_info, &old_ctx);

fs/btrfs/super.c

1574

btrfs_remount_cleanup(fs_info, old_ctx.mount_opt);

fs/btrfs/super.c

1575

clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);

fs/btrfs/super.c

1608

static inline int btrfs_calc_avail_data_space(struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

1612

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/super.c

1625

nr_devices = fs_info->fs_devices->open_devices;

fs/btrfs/super.c

1628

nr_devices = fs_info->fs_devices->open_devices;

fs/btrfs/super.c

1642

type = btrfs_data_alloc_profile(fs_info);

fs/btrfs/super.c

1728

struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);

fs/btrfs/super.c

1729

struct btrfs_super_block *disk_super = fs_info->super_copy;

fs/btrfs/super.c

1734

u32 bits = fs_info->sectorsize_bits;

fs/btrfs/super.c

1735

__be32 *fsid = (__be32 *)fs_info->fs_devices->fsid;

fs/btrfs/super.c

1737

struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;

fs/btrfs/super.c

1742

list_for_each_entry(found, &fs_info->space_info, list) {

fs/btrfs/super.c

1785

ret = btrfs_calc_avail_data_space(fs_info, &total_free_data);

fs/btrfs/super.c

1818

buf->f_bsize = fs_info->sectorsize;

fs/btrfs/super.c

1836

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

1838

return fs_info->fs_devices == p->fs_devices;

fs/btrfs/super.c

1843

struct btrfs_fs_info *fs_info = fc->s_fs_info;

fs/btrfs/super.c

1851

btrfs_ctx_to_info(fs_info, ctx);

fs/btrfs/super.c

1873

fs_info->fs_devices = fs_devices;

fs/btrfs/super.c

1891

fs_info->fs_devices = NULL;

fs/btrfs/super.c

1904

ASSERT(fc->s_fs_info == fs_info);

fs/btrfs/super.c

1908

fs_info->fs_devices = NULL;

fs/btrfs/super.c

1930

fs_info->fs_devices = NULL;

fs/btrfs/super.c

1940

set_device_specific_options(fs_info);

fs/btrfs/super.c

1951

btrfs_clear_oneshot_options(fs_info);

fs/btrfs/super.c

2042

struct btrfs_fs_info *fs_info = NULL;

fs/btrfs/super.c

2057

fs_info = kvzalloc_obj(struct btrfs_fs_info);

fs/btrfs/super.c

2058

if (!fs_info)

fs/btrfs/super.c

2061

fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL);

fs/btrfs/super.c

2062

fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL);

fs/btrfs/super.c

2063

if (!fs_info->super_copy || !fs_info->super_for_commit) {

fs/btrfs/super.c

2068

kfree(fs_info->super_copy);

fs/btrfs/super.c

2069

kfree(fs_info->super_for_commit);

fs/btrfs/super.c

2070

kvfree(fs_info);

fs/btrfs/super.c

2073

btrfs_init_fs_info(fs_info);

fs/btrfs/super.c

2077

btrfs_free_fs_info(fs_info);

fs/btrfs/super.c

2085

dup_fc->s_fs_info = fs_info;

fs/btrfs/super.c

2126

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2128

btrfs_free_fs_info(fs_info);

fs/btrfs/super.c

2134

struct btrfs_fs_info *fs_info = fc->s_fs_info;

fs/btrfs/super.c

2136

if (fs_info)

fs/btrfs/super.c

2137

btrfs_free_fs_info(fs_info);

fs/btrfs/super.c

2292

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2294

set_bit(BTRFS_FS_FROZEN, &fs_info->flags);

fs/btrfs/super.c

2301

return btrfs_commit_current_transaction(fs_info->tree_root);

fs/btrfs/super.c

2306

struct btrfs_fs_info *fs_info = dev->fs_info;

fs/btrfs/super.c

2313

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

fs/btrfs/super.c

2326

if (unlikely(csum_type != btrfs_super_csum_type(fs_info->super_copy))) {

fs/btrfs/super.c

2327

btrfs_err(fs_info, "csum type changed, has %u expect %u",

fs/btrfs/super.c

2328

csum_type, btrfs_super_csum_type(fs_info->super_copy));

fs/btrfs/super.c

2333

if (unlikely(btrfs_check_super_csum(fs_info, sb))) {

fs/btrfs/super.c

2334

btrfs_err(fs_info, "csum for on-disk super block no longer matches");

fs/btrfs/super.c

2340

ret = btrfs_validate_super(fs_info, sb, 0);

fs/btrfs/super.c

2344

last_trans = btrfs_get_last_trans_committed(fs_info);

fs/btrfs/super.c

2346

btrfs_err(fs_info, "transid mismatch, has %llu expect %llu",

fs/btrfs/super.c

2358

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2370

list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) {

fs/btrfs/super.c

2373

btrfs_handle_fs_error(fs_info, ret,

fs/btrfs/super.c

2379

clear_bit(BTRFS_FS_FROZEN, &fs_info->flags);

fs/btrfs/super.c

2391

struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);

fs/btrfs/super.c

2399

seq_escape(m, btrfs_dev_name(fs_info->fs_devices->latest_dev), " \t\n\\");

fs/btrfs/super.c

2407

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2408

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

fs/btrfs/super.c

2410

trace_btrfs_extent_map_shrinker_count(fs_info, nr);

fs/btrfs/super.c

2418

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2420

btrfs_free_extent_maps(fs_info, nr_to_scan);

fs/btrfs/super.c

2429

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2434

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

fs/btrfs/super.c

2435

device = btrfs_find_device(fs_info->fs_devices, &lookup_args);

fs/btrfs/super.c

2437

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

fs/btrfs/super.c

2439

btrfs_warn(fs_info, "unable to find btrfs device for block device '%pg'", bdev);

fs/btrfs/super.c

2448

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

fs/btrfs/super.c

2449

btrfs_warn(fs_info, "btrfs device id %llu is already missing", device->devid);

fs/btrfs/super.c

2459

can_rw = btrfs_check_rw_degradable(fs_info, device);

fs/btrfs/super.c

2460

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

fs/btrfs/super.c

2466

btrfs_crit(fs_info,

fs/btrfs/super.c

2471

btrfs_warn(fs_info,

fs/btrfs/super.c

2474

btrfs_set_opt(fs_info->mount_opt, DEGRADED);

fs/btrfs/super.c

2480

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

2482

btrfs_force_shutdown(fs_info);

fs/btrfs/super.c

2488

struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);

fs/btrfs/super.c

2490

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/super.c

2491

btrfs_show_zoned_stats(fs_info, seq);

fs/btrfs/super.c

667

static void btrfs_clear_oneshot_options(struct btrfs_fs_info *fs_info)

fs/btrfs/super.c

669

btrfs_clear_opt(fs_info->mount_opt, USEBACKUPROOT);

fs/btrfs/super.c

670

btrfs_clear_opt(fs_info->mount_opt, CLEAR_CACHE);

fs/btrfs/super.c

671

btrfs_clear_opt(fs_info->mount_opt, NOSPACECACHE);

fs/btrfs/super.c

674

static bool check_ro_option(const struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

679

btrfs_err(fs_info, "%s must be used with ro mount option",

fs/btrfs/super.c

71

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

73

btrfs_info(fs_info, "last unmount of filesystem %pU", fs_info->fs_devices->fsid);

fs/btrfs/super.c

737

void btrfs_set_free_space_cache_settings(struct btrfs_fs_info *fs_info)

fs/btrfs/super.c

739

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

fs/btrfs/super.c

74

close_ctree(fs_info);

fs/btrfs/super.c

740

btrfs_info(fs_info,

fs/btrfs/super.c

742

fs_info->sectorsize, PAGE_SIZE);

fs/btrfs/super.c

743

btrfs_clear_opt(fs_info->mount_opt, SPACE_CACHE);

fs/btrfs/super.c

744

btrfs_set_opt(fs_info->mount_opt, FREE_SPACE_TREE);

fs/btrfs/super.c

751

if (btrfs_test_opt(fs_info, FREE_SPACE_TREE))

fs/btrfs/super.c

754

if (btrfs_is_zoned(fs_info) &&

fs/btrfs/super.c

755

btrfs_free_space_cache_v1_active(fs_info)) {

fs/btrfs/super.c

756

btrfs_info(fs_info, "zoned: clearing existing space cache");

fs/btrfs/super.c

757

btrfs_set_super_cache_generation(fs_info->super_copy, 0);

fs/btrfs/super.c

761

if (btrfs_test_opt(fs_info, SPACE_CACHE))

fs/btrfs/super.c

764

if (btrfs_test_opt(fs_info, NOSPACECACHE))

fs/btrfs/super.c

771

if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE))

fs/btrfs/super.c

772

btrfs_set_opt(fs_info->mount_opt, FREE_SPACE_TREE);

fs/btrfs/super.c

773

else if (btrfs_free_space_cache_v1_active(fs_info))

fs/btrfs/super.c

774

btrfs_set_opt(fs_info->mount_opt, SPACE_CACHE);

fs/btrfs/super.c

777

static void set_device_specific_options(struct btrfs_fs_info *fs_info)

fs/btrfs/super.c

779

if (!btrfs_test_opt(fs_info, NOSSD) &&

fs/btrfs/super.c

780

!fs_info->fs_devices->rotating)

fs/btrfs/super.c

781

btrfs_set_opt(fs_info->mount_opt, SSD);

fs/btrfs/super.c

792

if (!(btrfs_test_opt(fs_info, DISCARD_SYNC) ||

fs/btrfs/super.c

793

btrfs_test_opt(fs_info, DISCARD_ASYNC) ||

fs/btrfs/super.c

794

btrfs_test_opt(fs_info, NODISCARD)) &&

fs/btrfs/super.c

795

fs_info->fs_devices->discardable &&

fs/btrfs/super.c

796

!btrfs_is_zoned(fs_info))

fs/btrfs/super.c

797

btrfs_set_opt(fs_info->mount_opt, DISCARD_ASYNC);

fs/btrfs/super.c

800

char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,

fs/btrfs/super.c

803

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/super.c

859

fs_root = btrfs_get_fs_root(fs_info, subvol_objectid, true);

fs/btrfs/super.c

918

static int get_default_subvol_objectid(struct btrfs_fs_info *fs_info, u64 *objectid)

fs/btrfs/super.c

920

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/super.c

936

dir_id = btrfs_super_root_dir(fs_info->super_copy);

fs/btrfs/super.c

960

struct btrfs_fs_info *fs_info = btrfs_sb(sb);

fs/btrfs/super.c

977

btrfs_err(fs_info, "super_setup_bdi failed");

fs/btrfs/super.c

983

btrfs_err(fs_info, "open_ctree failed: %d", ret);

fs/btrfs/super.c

987

btrfs_emit_options(fs_info, NULL);

fs/btrfs/super.c

989

inode = btrfs_iget(BTRFS_FIRST_FREE_OBJECTID, fs_info->fs_root);

fs/btrfs/super.c

992

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

set_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);

fs/btrfs/tests/btrfs-tests.c

150

test_mnt->mnt_sb->s_fs_info = fs_info;

fs/btrfs/tests/btrfs-tests.c

152

return fs_info;

fs/btrfs/tests/btrfs-tests.c

155

void btrfs_free_dummy_fs_info(struct btrfs_fs_info *fs_info)

fs/btrfs/tests/btrfs-tests.c

161

if (!fs_info)

fs/btrfs/tests/btrfs-tests.c

164

if (WARN_ON(!btrfs_is_testing(fs_info)))

fs/btrfs/tests/btrfs-tests.c

169

xa_lock_irq(&fs_info->buffer_tree);

fs/btrfs/tests/btrfs-tests.c

170

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

fs/btrfs/tests/btrfs-tests.c

171

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/tests/btrfs-tests.c

173

xa_lock_irq(&fs_info->buffer_tree);

fs/btrfs/tests/btrfs-tests.c

175

xa_unlock_irq(&fs_info->buffer_tree);

fs/btrfs/tests/btrfs-tests.c

177

btrfs_mapping_tree_free(fs_info);

fs/btrfs/tests/btrfs-tests.c

178

list_for_each_entry_safe(dev, tmp, &fs_info->fs_devices->devices,

fs/btrfs/tests/btrfs-tests.c

182

btrfs_free_qgroup_config(fs_info);

fs/btrfs/tests/btrfs-tests.c

183

btrfs_free_fs_roots(fs_info);

fs/btrfs/tests/btrfs-tests.c

184

kfree(fs_info->super_copy);

fs/btrfs/tests/btrfs-tests.c

185

btrfs_check_leaked_roots(fs_info);

fs/btrfs/tests/btrfs-tests.c

186

btrfs_extent_buffer_leak_debug_check(fs_info);

fs/btrfs/tests/btrfs-tests.c

187

kfree(fs_info->fs_devices);

fs/btrfs/tests/btrfs-tests.c

188

kfree(fs_info);

fs/btrfs/tests/btrfs-tests.c

203

btrfs_alloc_dummy_block_group(struct btrfs_fs_info *fs_info,

fs/btrfs/tests/btrfs-tests.c

219

cache->full_stripe_len = fs_info->sectorsize;

fs/btrfs/tests/btrfs-tests.c

220

cache->fs_info = fs_info;

fs/btrfs/tests/btrfs-tests.c

240

void btrfs_init_dummy_transaction(struct btrfs_transaction *trans, struct btrfs_fs_info *fs_info)

fs/btrfs/tests/btrfs-tests.c

243

trans->fs_info = fs_info;

fs/btrfs/tests/btrfs-tests.c

250

struct btrfs_fs_info *fs_info)

fs/btrfs/tests/btrfs-tests.c

255

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

1007

struct btrfs_fs_info *fs_info;

fs/btrfs/tests/free-space-tests.c

1013

fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);

fs/btrfs/tests/free-space-tests.c

1014

if (!fs_info) {

fs/btrfs/tests/free-space-tests.c

1024

cache = btrfs_alloc_dummy_block_group(fs_info,

fs/btrfs/tests/free-space-tests.c

1028

btrfs_free_dummy_fs_info(fs_info);

fs/btrfs/tests/free-space-tests.c

1032

root = btrfs_alloc_dummy_root(fs_info);

fs/btrfs/tests/free-space-tests.c

1061

btrfs_free_dummy_fs_info(fs_info);

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/transaction.c

1006

void btrfs_throttle(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

1008

wait_current_trans(fs_info, TRANS_START);

fs/btrfs/transaction.c

1019

if (btrfs_check_space_for_delayed_refs(trans->fs_info))

fs/btrfs/transaction.c

1022

return !!btrfs_block_rsv_check(&trans->fs_info->global_block_rsv, 50);

fs/btrfs/transaction.c

1028

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

1046

ASSERT(trans->block_rsv == &fs_info->trans_block_rsv);

fs/btrfs/transaction.c

1047

trace_btrfs_space_reservation(fs_info, "transaction",

fs/btrfs/transaction.c

1049

btrfs_block_rsv_release(fs_info, trans->block_rsv,

fs/btrfs/transaction.c

1056

trace_btrfs_space_reservation(fs_info, "local_delayed_refs_rsv",

fs/btrfs/transaction.c

1059

btrfs_block_rsv_release(fs_info, &trans->delayed_rsv,

fs/btrfs/transaction.c

1067

struct btrfs_fs_info *info = trans->fs_info;

fs/btrfs/transaction.c

1132

int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info,

fs/btrfs/transaction.c

1136

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

fs/btrfs/transaction.c

1168

btrfs_btree_wait_writeback_range(fs_info, start, end);

fs/btrfs/transaction.c

1185

static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info,

fs/btrfs/transaction.c

1208

btrfs_btree_wait_writeback_range(fs_info, start, end);

fs/btrfs/transaction.c

1219

static int btrfs_wait_extents(struct btrfs_fs_info *fs_info,

fs/btrfs/transaction.c

1225

ret = __btrfs_wait_marked_extents(fs_info, dirty_pages);

fs/btrfs/transaction.c

1226

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

fs/btrfs/transaction.c

1236

struct btrfs_fs_info *fs_info = log_root->fs_info;

fs/btrfs/transaction.c

1244

ret = __btrfs_wait_marked_extents(fs_info, dirty_pages);

fs/btrfs/transaction.c

1246

test_and_clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags))

fs/btrfs/transaction.c

1250

test_and_clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags))

fs/btrfs/transaction.c

1270

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

1274

ret = btrfs_write_marked_extents(fs_info, dirty_pages, EXTENT_DIRTY);

fs/btrfs/transaction.c

1276

ret2 = btrfs_wait_extents(fs_info, dirty_pages);

fs/btrfs/transaction.c

1304

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

1305

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/transaction.c

1337

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

1350

eb = btrfs_lock_root_node(fs_info->tree_root);

fs/btrfs/transaction.c

1351

ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,

fs/btrfs/transaction.c

1374

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

fs/btrfs/transaction.c

1377

root = list_first_entry(&fs_info->dirty_cowonly_roots,

fs/btrfs/transaction.c

1409

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

fs/btrfs/transaction.c

1413

fs_info->dev_replace.committed_cursor_left =

fs/btrfs/transaction.c

1414

fs_info->dev_replace.cursor_left_last_write_of_item;

fs/btrfs/transaction.c

1423

void btrfs_maybe_wake_unfinished_drop(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

1430

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

1431

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

fs/btrfs/transaction.c

1432

struct btrfs_root *root = list_first_entry(&fs_info->dead_roots,

fs/btrfs/transaction.c

1436

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

1440

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

1442

btrfs_wake_unfinished_drop(fs_info);

fs/btrfs/transaction.c

1452

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

1454

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

1460

list_add(&root->root_list, &fs_info->dead_roots);

fs/btrfs/transaction.c

1462

list_add_tail(&root->root_list, &fs_info->dead_roots);

fs/btrfs/transaction.c

1464

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

1473

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

148

btrfs_err(transaction->fs_info,

fs/btrfs/transaction.c

1485

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

1487

ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,

fs/btrfs/transaction.c

1511

radix_tree_tag_clear(&fs_info->fs_roots_radix,

fs/btrfs/transaction.c

1515

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

1533

ret2 = btrfs_update_root(trans, fs_info->tree_root,

fs/btrfs/transaction.c

1538

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

1541

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

1558

struct btrfs_fs_info *fs_info = src->fs_info;

fs/btrfs/transaction.c

1565

if (!btrfs_qgroup_full_accounting(fs_info))

fs/btrfs/transaction.c

1626

btrfs_err(fs_info,

fs/btrfs/transaction.c

1654

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

1657

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/transaction.c

168

spin_lock(&transaction->fs_info->unused_bgs_lock);

fs/btrfs/transaction.c

170

spin_unlock(&transaction->fs_info->unused_bgs_lock);

fs/btrfs/transaction.c

1707

pending->error = btrfs_block_rsv_add(fs_info,

fs/btrfs/transaction.c

1718

trace_btrfs_space_reservation(fs_info, "transaction",

fs/btrfs/transaction.c

1752

if (unlikely(ret != -ENOTCONN || btrfs_qgroup_enabled(fs_info))) {

fs/btrfs/transaction.c

182

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

1851

pending->snap = btrfs_get_new_fs_root(fs_info, objectid, &pending->anon_dev);

fs/btrfs/transaction.c

1871

if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_FULL)

fs/btrfs/transaction.c

1874

else if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)

fs/btrfs/transaction.c

192

down_write(&fs_info->commit_root_sem);

fs/btrfs/transaction.c

194

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

fs/btrfs/transaction.c

195

fs_info->last_reloc_trans = trans->transid;

fs/btrfs/transaction.c

1965

static void update_super_roots(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

1970

super = fs_info->super_copy;

fs/btrfs/transaction.c

1972

root_item = &fs_info->chunk_root->root_item;

fs/btrfs/transaction.c

1977

root_item = &fs_info->tree_root->root_item;

fs/btrfs/transaction.c

1981

if (btrfs_test_opt(fs_info, SPACE_CACHE))

fs/btrfs/transaction.c

1983

else if (test_bit(BTRFS_FS_CLEANUP_SPACE_CACHE_V1, &fs_info->flags))

fs/btrfs/transaction.c

1985

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

fs/btrfs/transaction.c

1988

if (btrfs_fs_incompat(fs_info, REMAP_TREE)) {

fs/btrfs/transaction.c

1989

root_item = &fs_info->remap_root->root_item;

fs/btrfs/transaction.c

2011

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

2015

set_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags);

fs/btrfs/transaction.c

2016

wake_up_process(fs_info->transaction_kthread);

fs/btrfs/transaction.c

2028

btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_PREP);

fs/btrfs/transaction.c

2029

wait_event(fs_info->transaction_blocked_wait,

fs/btrfs/transaction.c

2056

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

2063

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2072

if (cur_trans == fs_info->running_transaction) {

fs/btrfs/transaction.c

2074

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2080

btrfs_might_wait_for_event(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

2084

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2097

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2101

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2102

if (cur_trans == fs_info->running_transaction)

fs/btrfs/transaction.c

2103

fs_info->running_transaction = NULL;

fs/btrfs/transaction.c

2104

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2107

sb_end_intwrite(fs_info->sb);

fs/btrfs/transaction.c

2111

trace_btrfs_transaction_commit(fs_info);

fs/btrfs/transaction.c

2127

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

fs/btrfs/transaction.c

2128

btrfs_scrub_cancel(fs_info);

fs/btrfs/transaction.c

2139

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

214

btrfs_drop_and_free_fs_root(fs_info, root);

fs/btrfs/transaction.c

2143

btrfs_dec_delayed_refs_rsv_bg_inserts(fs_info);

fs/btrfs/transaction.c

2148

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/transaction.c

2151

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/transaction.c

2155

static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

2174

if (btrfs_test_opt(fs_info, FLUSHONCOMMIT))

fs/btrfs/transaction.c

2175

try_to_writeback_inodes_sb(fs_info->sb, WB_REASON_SYNC);

fs/btrfs/transaction.c

2179

static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

2181

if (btrfs_test_opt(fs_info, FLUSHONCOMMIT))

fs/btrfs/transaction.c

2182

btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);

fs/btrfs/transaction.c

219

up_write(&fs_info->commit_root_sem);

fs/btrfs/transaction.c

2200

lockdep_assert_held(&trans->fs_info->trans_lock);

fs/btrfs/transaction.c

2207

static void update_commit_stats(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

2210

ktime_t interval = now - fs_info->commit_stats.critical_section_start_time;

fs/btrfs/transaction.c

2212

ASSERT(fs_info->commit_stats.critical_section_start_time);

fs/btrfs/transaction.c

2214

fs_info->commit_stats.commit_count++;

fs/btrfs/transaction.c

2215

fs_info->commit_stats.last_commit_dur = interval;

fs/btrfs/transaction.c

2216

fs_info->commit_stats.max_commit_dur =

fs/btrfs/transaction.c

2217

max_t(u64, fs_info->commit_stats.max_commit_dur, interval);

fs/btrfs/transaction.c

2218

fs_info->commit_stats.total_commit_dur += interval;

fs/btrfs/transaction.c

2219

fs_info->commit_stats.critical_section_start_time = 0;

fs/btrfs/transaction.c

2224

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

2231

btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_PREP);

fs/btrfs/transaction.c

2233

clear_bit(BTRFS_FS_NEED_TRANS_COMMIT, &fs_info->flags);

fs/btrfs/transaction.c

2277

mutex_lock(&fs_info->ro_block_group_mutex);

fs/btrfs/transaction.c

2281

mutex_unlock(&fs_info->ro_block_group_mutex);

fs/btrfs/transaction.c

2290

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2296

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2302

btrfs_trans_state_lockdep_release(fs_info,

fs/btrfs/transaction.c

2316

wake_up(&fs_info->transaction_blocked_wait);

fs/btrfs/transaction.c

2317

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_PREP);

fs/btrfs/transaction.c

2319

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

fs/btrfs/transaction.c

2328

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2337

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2346

if (BTRFS_FS_ERROR(fs_info)) {

fs/btrfs/transaction.c

2347

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2354

wake_up(&fs_info->transaction_blocked_wait);

fs/btrfs/transaction.c

2355

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2361

fs_info->commit_stats.critical_section_start_time = ktime_get_ns();

fs/btrfs/transaction.c

2364

ret = btrfs_start_delalloc_flush(fs_info);

fs/btrfs/transaction.c

2377

btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

2378

btrfs_might_wait_for_event(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

2385

btrfs_lockdep_release(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

2389

btrfs_wait_delalloc_flush(fs_info);

fs/btrfs/transaction.c

2396

btrfs_might_wait_for_event(fs_info, btrfs_trans_pending_ordered);

fs/btrfs/transaction.c

2400

btrfs_scrub_pause(fs_info);

fs/btrfs/transaction.c

2406

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2409

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2416

btrfs_lockdep_release(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

2417

btrfs_might_wait_for_event(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

2427

btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED);

fs/btrfs/transaction.c

2428

btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED);

fs/btrfs/transaction.c

2429

btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED);

fs/btrfs/transaction.c

2436

clear_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags);

fs/btrfs/transaction.c

2440

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED);

fs/btrfs/transaction.c

2448

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/transaction.c

2481

btrfs_assert_delayed_root_empty(fs_info);

fs/btrfs/transaction.c

2492

btrfs_free_log_root_tree(trans, fs_info);

fs/btrfs/transaction.c

2515

cur_trans = fs_info->running_transaction;

fs/btrfs/transaction.c

2517

btrfs_set_root_node(&fs_info->tree_root->root_item,

fs/btrfs/transaction.c

2518

fs_info->tree_root->node);

fs/btrfs/transaction.c

2519

list_add_tail(&fs_info->tree_root->dirty_list,

fs/btrfs/transaction.c

2522

btrfs_set_root_node(&fs_info->chunk_root->root_item,

fs/btrfs/transaction.c

2523

fs_info->chunk_root->node);

fs/btrfs/transaction.c

2524

list_add_tail(&fs_info->chunk_root->dirty_list,

fs/btrfs/transaction.c

2531

update_super_roots(fs_info);

fs/btrfs/transaction.c

2533

btrfs_set_super_log_root(fs_info->super_copy, 0);

fs/btrfs/transaction.c

2534

btrfs_set_super_log_root_level(fs_info->super_copy, 0);

fs/btrfs/transaction.c

2535

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

fs/btrfs/transaction.c

2536

sizeof(*fs_info->super_copy));

fs/btrfs/transaction.c

2540

clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags);

fs/btrfs/transaction.c

2541

clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags);

fs/btrfs/transaction.c

2553

mutex_lock(&fs_info->tree_log_mutex);

fs/btrfs/transaction.c

2555

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2557

fs_info->running_transaction = NULL;

fs/btrfs/transaction.c

2558

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2559

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/transaction.c

256

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

2561

wake_up(&fs_info->transaction_wait);

fs/btrfs/transaction.c

2562

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED);

fs/btrfs/transaction.c

2565

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

fs/btrfs/transaction.c

2566

fs_info->cleaner_kthread)

fs/btrfs/transaction.c

2567

wake_up_process(fs_info->cleaner_kthread);

fs/btrfs/transaction.c

2571

btrfs_err(fs_info, "error while writing out transaction: %d", ret);

fs/btrfs/transaction.c

2572

mutex_unlock(&fs_info->tree_log_mutex);

fs/btrfs/transaction.c

2576

ret = write_all_supers(fs_info, 0);

fs/btrfs/transaction.c

2581

mutex_unlock(&fs_info->tree_log_mutex);

fs/btrfs/transaction.c

2585

update_commit_stats(fs_info);

fs/btrfs/transaction.c

2592

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED);

fs/btrfs/transaction.c

2599

btrfs_clear_space_info_full(fs_info);

fs/btrfs/transaction.c

2601

btrfs_set_last_trans_committed(fs_info, cur_trans->transid);

fs/btrfs/transaction.c

2608

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED);

fs/btrfs/transaction.c

261

btrfs_block_rsv_release(fs_info, &fs_info->chunk_block_rsv,

fs/btrfs/transaction.c

2610

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2612

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2618

sb_end_intwrite(fs_info->sb);

fs/btrfs/transaction.c

2620

trace_btrfs_transaction_commit(fs_info);

fs/btrfs/transaction.c

2622

btrfs_scrub_continue(fs_info);

fs/btrfs/transaction.c

2632

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/transaction.c

2633

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED);

fs/btrfs/transaction.c

2635

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED);

fs/btrfs/transaction.c

2636

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED);

fs/btrfs/transaction.c

2637

btrfs_scrub_continue(fs_info);

fs/btrfs/transaction.c

2643

btrfs_warn(fs_info, "Skipping commit of aborted transaction.");

fs/btrfs/transaction.c

2651

btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

2652

btrfs_lockdep_release(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

2656

btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_PREP);

fs/btrfs/transaction.c

2671

int btrfs_clean_one_deleted_snapshot(struct btrfs_fs_info *fs_info)

fs/btrfs/transaction.c

2676

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2677

if (list_empty(&fs_info->dead_roots)) {

fs/btrfs/transaction.c

2678

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2681

root = list_first_entry(&fs_info->dead_roots,

fs/btrfs/transaction.c

2684

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

2686

btrfs_debug(fs_info, "cleaner removing %llu", btrfs_root_id(root));

fs/btrfs/transaction.c

269

static noinline int join_transaction(struct btrfs_fs_info *fs_info,

fs/btrfs/transaction.c

2717

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/transaction.c

2722

btrfs_dump_space_info_for_trans_abort(fs_info);

fs/btrfs/transaction.c

2724

wake_up(&fs_info->transaction_wait);

fs/btrfs/transaction.c

2725

wake_up(&fs_info->transaction_blocked_wait);

fs/btrfs/transaction.c

2726

__btrfs_handle_fs_error(fs_info, function, line, error, NULL);

fs/btrfs/transaction.c

274

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

277

if (BTRFS_FS_ERROR(fs_info)) {

fs/btrfs/transaction.c

278

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

282

cur_trans = fs_info->running_transaction;

fs/btrfs/transaction.c

287

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

291

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

297

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

298

btrfs_lockdep_acquire(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

299

btrfs_lockdep_acquire(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

302

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

322

btrfs_lockdep_acquire(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

323

btrfs_lockdep_acquire(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

325

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

326

if (fs_info->running_transaction) {

fs/btrfs/transaction.c

331

btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

332

btrfs_lockdep_release(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

335

} else if (BTRFS_FS_ERROR(fs_info)) {

fs/btrfs/transaction.c

336

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

337

btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters);

fs/btrfs/transaction.c

338

btrfs_lockdep_release(fs_info, btrfs_trans_num_writers);

fs/btrfs/transaction.c

343

cur_trans->fs_info = fs_info;

fs/btrfs/transaction.c

369

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

fs/btrfs/transaction.c

371

if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log))

fs/btrfs/transaction.c

373

atomic64_set(&fs_info->tree_mod_seq, 0);

fs/btrfs/transaction.c

387

list_add_tail(&cur_trans->list, &fs_info->trans_list);

fs/btrfs/transaction.c

388

btrfs_extent_io_tree_init(fs_info, &cur_trans->dirty_pages,

fs/btrfs/transaction.c

390

btrfs_extent_io_tree_init(fs_info, &cur_trans->pinned_extents,

fs/btrfs/transaction.c

392

btrfs_set_fs_generation(fs_info, fs_info->generation + 1);

fs/btrfs/transaction.c

393

cur_trans->transid = fs_info->generation;

fs/btrfs/transaction.c

394

fs_info->running_transaction = cur_trans;

fs/btrfs/transaction.c

396

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

411

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

430

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

432

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

435

radix_tree_tag_set(&fs_info->fs_roots_radix,

fs/btrfs/transaction.c

438

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

471

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

480

spin_lock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

481

radix_tree_tag_clear(&fs_info->fs_roots_radix,

fs/btrfs/transaction.c

484

spin_unlock(&fs_info->fs_roots_radix_lock);

fs/btrfs/transaction.c

490

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

505

mutex_lock(&fs_info->reloc_mutex);

fs/btrfs/transaction.c

507

mutex_unlock(&fs_info->reloc_mutex);

fs/btrfs/transaction.c

523

static void wait_current_trans(struct btrfs_fs_info *fs_info, unsigned int type)

fs/btrfs/transaction.c

527

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

528

cur_trans = fs_info->running_transaction;

fs/btrfs/transaction.c

532

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

534

btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED);

fs/btrfs/transaction.c

535

wait_event(fs_info->transaction_wait,

fs/btrfs/transaction.c

540

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

544

static bool may_wait_transaction(struct btrfs_fs_info *fs_info, int type)

fs/btrfs/transaction.c

546

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

fs/btrfs/transaction.c

557

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

559

if (!fs_info->reloc_ctl ||

fs/btrfs/transaction.c

568

static int btrfs_reserve_trans_metadata(struct btrfs_fs_info *fs_info,

fs/btrfs/transaction.c

573

struct btrfs_space_info *si = fs_info->trans_block_rsv.space_info;

fs/btrfs/transaction.c

602

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/transaction.c

603

struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;

fs/btrfs/transaction.c

604

struct btrfs_block_rsv *trans_rsv = &fs_info->trans_block_rsv;

fs/btrfs/transaction.c

614

if (BTRFS_FS_ERROR(fs_info))

fs/btrfs/transaction.c

631

if (num_items && root != fs_info->chunk_root) {

fs/btrfs/transaction.c

632

qgroup_reserved = num_items * fs_info->nodesize;

fs/btrfs/transaction.c

643

num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items);

fs/btrfs/transaction.c

652

delayed_refs_bytes = btrfs_calc_delayed_ref_bytes(fs_info, num_items);

fs/btrfs/transaction.c

658

num_bytes += fs_info->nodesize;

fs/btrfs/transaction.c

662

ret = btrfs_reserve_trans_metadata(fs_info, flush, num_bytes,

fs/btrfs/transaction.c

680

ret = btrfs_delayed_refs_rsv_refill(fs_info, flush);

fs/btrfs/transaction.c

702

sb_start_intwrite(fs_info->sb);

fs/btrfs/transaction.c

704

if (may_wait_transaction(fs_info, type))

fs/btrfs/transaction.c

705

wait_current_trans(fs_info, type);

fs/btrfs/transaction.c

708

ret = join_transaction(fs_info, type);

fs/btrfs/transaction.c

710

wait_current_trans(fs_info, type);

fs/btrfs/transaction.c

720

cur_trans = fs_info->running_transaction;

fs/btrfs/transaction.c

725

h->fs_info = root->fs_info;

fs/btrfs/transaction.c

729

btrfs_init_metadata_block_rsv(fs_info, &h->delayed_rsv, BTRFS_BLOCK_RSV_DELREFS);

fs/btrfs/transaction.c

733

may_wait_transaction(fs_info, type)) {

fs/btrfs/transaction.c

740

trace_btrfs_space_reservation(fs_info, "transaction",

fs/btrfs/transaction.c

745

trace_btrfs_space_reservation(fs_info,

fs/btrfs/transaction.c

770

btrfs_chunk_alloc(h, space_info, btrfs_get_alloc_profile(fs_info, flags),

fs/btrfs/transaction.c

804

sb_end_intwrite(fs_info->sb);

fs/btrfs/transaction.c

808

btrfs_block_rsv_release(fs_info, trans_rsv, num_bytes, NULL);

fs/btrfs/transaction.c

892

ret = btrfs_wait_for_commit(root->fs_info, 0);

fs/btrfs/transaction.c

904

struct btrfs_fs_info *fs_info = commit->fs_info;

fs/btrfs/transaction.c

913

btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED);

fs/btrfs/transaction.c

915

btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED);

fs/btrfs/transaction.c

932

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

933

commit = list_first_entry_or_null(&fs_info->trans_list,

fs/btrfs/transaction.c

937

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

942

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

946

int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid)

fs/btrfs/transaction.c

952

if (transid <= btrfs_get_last_trans_committed(fs_info))

fs/btrfs/transaction.c

956

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

957

list_for_each_entry(t, &fs_info->trans_list, list) {

fs/btrfs/transaction.c

969

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.c

976

if (transid > btrfs_get_last_trans_committed(fs_info))

fs/btrfs/transaction.c

982

spin_lock(&fs_info->trans_lock);

fs/btrfs/transaction.c

983

list_for_each_entry_reverse(t, &fs_info->trans_list,

fs/btrfs/transaction.c

993

spin_unlock(&fs_info->trans_lock);

fs/btrfs/transaction.h

110

struct btrfs_fs_info *fs_info;

fs/btrfs/transaction.h

162

struct btrfs_fs_info *fs_info;

fs/btrfs/transaction.h

251

&((trans)->fs_info->fs_state))) { \

fs/btrfs/transaction.h

259

btrfs_err((trans)->fs_info, \

fs/btrfs/transaction.h

280

int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid);

fs/btrfs/transaction.h

283

void btrfs_maybe_wake_unfinished_drop(struct btrfs_fs_info *fs_info);

fs/btrfs/transaction.h

284

int btrfs_clean_one_deleted_snapshot(struct btrfs_fs_info *fs_info);

fs/btrfs/transaction.h

290

void btrfs_throttle(struct btrfs_fs_info *fs_info);

fs/btrfs/transaction.h

293

int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info,

fs/btrfs/tree-checker.c

1005

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1025

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

1029

chunk_err(fs_info, leaf, chunk, key->offset,

fs/btrfs/tree-checker.c

1033

BTRFS_LEAF_DATA_SIZE(fs_info));

fs/btrfs/tree-checker.c

1044

chunk_err(fs_info, leaf, chunk, key->offset,

fs/btrfs/tree-checker.c

1051

return btrfs_check_chunk_valid(fs_info, leaf, chunk, key->offset,

fs/btrfs/tree-checker.c

1052

fs_info->sectorsize);

fs/btrfs/tree-checker.c

1071

btrfs_crit(eb->fs_info,

fs/btrfs/tree-checker.c

1129

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

1131

u64 super_gen = btrfs_super_generation(fs_info->super_copy);

fs/btrfs/tree-checker.c

1205

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

fs/btrfs/tree-checker.c

1218

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

1248

btrfs_super_generation(fs_info->super_copy) + 1)) {

fs/btrfs/tree-checker.c

1252

btrfs_super_generation(fs_info->super_copy) + 1);

fs/btrfs/tree-checker.c

1256

btrfs_super_generation(fs_info->super_copy) + 1)) {

fs/btrfs/tree-checker.c

1260

btrfs_super_generation(fs_info->super_copy) + 1);

fs/btrfs/tree-checker.c

1264

btrfs_super_generation(fs_info->super_copy) + 1)) {

fs/btrfs/tree-checker.c

1268

btrfs_super_generation(fs_info->super_copy) + 1);

fs/btrfs/tree-checker.c

1273

if (unlikely(!IS_ALIGNED(btrfs_root_bytenr(&ri), fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1276

btrfs_root_bytenr(&ri), fs_info->sectorsize);

fs/btrfs/tree-checker.c

129

end = ALIGN(key->offset + len, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1335

len = eb->fs_info->nodesize;

fs/btrfs/tree-checker.c

1344

btrfs_crit(eb->fs_info,

fs/btrfs/tree-checker.c

1368

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

1382

!btrfs_fs_incompat(fs_info, SKINNY_METADATA))) {

fs/btrfs/tree-checker.c

1388

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

fs/btrfs/tree-checker.c

1391

key->objectid, fs_info->sectorsize);

fs/btrfs/tree-checker.c

1439

BTRFS_LEAF_DATA_SIZE(fs_info));

fs/btrfs/tree-checker.c

1450

btrfs_super_generation(fs_info->super_copy) + 1)) {

fs/btrfs/tree-checker.c

1454

btrfs_super_generation(fs_info->super_copy) + 1);

fs/btrfs/tree-checker.c

146

const struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/tree-checker.c

1468

key->offset != fs_info->nodesize)) {

fs/btrfs/tree-checker.c

1471

key->offset, fs_info->nodesize);

fs/btrfs/tree-checker.c

1481

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

fs/btrfs/tree-checker.c

1484

key->offset, fs_info->sectorsize);

fs/btrfs/tree-checker.c

1547

fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1550

inline_offset, fs_info->sectorsize);

fs/btrfs/tree-checker.c

158

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

1582

fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1585

dref_offset, fs_info->sectorsize);

fs/btrfs/tree-checker.c

1599

fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1602

inline_offset, fs_info->sectorsize);

fs/btrfs/tree-checker.c

1613

WARN_ON(!btrfs_fs_incompat(fs_info, SIMPLE_QUOTA));

fs/btrfs/tree-checker.c

1660

prev_end += fs_info->nodesize;

fs/btrfs/tree-checker.c

1701

if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1704

key->objectid, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1708

!IS_ALIGNED(key->offset, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1711

key->offset, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1731

if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1734

key->objectid, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1763

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

fs/btrfs/tree-checker.c

1766

offset, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1795

sizeof(*iref), BTRFS_LEAF_DATA_SIZE(leaf->fs_info));

fs/btrfs/tree-checker.c

1866

if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1869

key->objectid, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1873

if (unlikely(!btrfs_fs_incompat(leaf->fs_info, RAID_STRIPE_TREE))) {

fs/btrfs/tree-checker.c

1888

const u32 sectorsize = leaf->fs_info->sectorsize;

fs/btrfs/tree-checker.c

2020

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

2070

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))

fs/btrfs/tree-checker.c

211

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

2121

item_end_expected = BTRFS_LEAF_DATA_SIZE(fs_info);

fs/btrfs/tree-checker.c

213

u32 sectorsize = fs_info->sectorsize;

fs/btrfs/tree-checker.c

2137

if (unlikely(item_data_end > BTRFS_LEAF_DATA_SIZE(fs_info))) {

fs/btrfs/tree-checker.c

2140

item_data_end, BTRFS_LEAF_DATA_SIZE(fs_info));

fs/btrfs/tree-checker.c

2181

struct btrfs_fs_info *fs_info = node->fs_info;

fs/btrfs/tree-checker.c

2199

if (unlikely(nr == 0 || nr > BTRFS_NODEPTRS_PER_BLOCK(fs_info))) {

fs/btrfs/tree-checker.c

2200

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

2204

BTRFS_NODEPTRS_PER_BLOCK(fs_info));

fs/btrfs/tree-checker.c

2218

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

fs/btrfs/tree-checker.c

2221

bytenr, fs_info->sectorsize);

fs/btrfs/tree-checker.c

2256

if (btrfs_is_testing(eb->fs_info))

fs/btrfs/tree-checker.c

2277

btrfs_crit(eb->fs_info,

fs/btrfs/tree-checker.c

2292

btrfs_crit(eb->fs_info,

fs/btrfs/tree-checker.c

2305

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/tree-checker.c

2313

btrfs_err(fs_info,

fs/btrfs/tree-checker.c

2328

if (btrfs_header_generation(eb) > btrfs_get_last_trans_committed(fs_info))

fs/btrfs/tree-checker.c

2333

btrfs_err(fs_info,

fs/btrfs/tree-checker.c

2348

btrfs_err(fs_info,

fs/btrfs/tree-checker.c

368

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

369

u32 sectorsize = fs_info->sectorsize;

fs/btrfs/tree-checker.c

370

const u32 csumsize = fs_info->csum_size;

fs/btrfs/tree-checker.c

525

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

608

if (unlikely(name_len + data_len > BTRFS_MAX_XATTR_SIZE(fs_info))) {

fs/btrfs/tree-checker.c

612

BTRFS_MAX_XATTR_SIZE(fs_info));

fs/btrfs/tree-checker.c

662

const struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/tree-checker.c

674

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

685

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

69

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

703

if (btrfs_fs_incompat(fs_info, REMAP_TREE))

fs/btrfs/tree-checker.c

718

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/tree-checker.c

725

if (unlikely(fs_info->nr_global_roots &&

fs/btrfs/tree-checker.c

726

chunk_objectid >= fs_info->nr_global_roots)) {

fs/btrfs/tree-checker.c

730

fs_info->nr_global_roots);

fs/btrfs/tree-checker.c

758

!btrfs_fs_incompat(fs_info, REMAP_TREE))) {

fs/btrfs/tree-checker.c

785

static void chunk_err(const struct btrfs_fs_info *fs_info,

fs/btrfs/tree-checker.c

814

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

818

btrfs_crit(fs_info,

fs/btrfs/tree-checker.c

85

const struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/tree-checker.c

860

int btrfs_check_chunk_valid(const struct btrfs_fs_info *fs_info,

fs/btrfs/tree-checker.c

900

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

905

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

911

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

917

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

923

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

929

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

934

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

940

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

954

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

960

chunk_err(fs_info, leaf, chunk, logical,

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

974

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

983

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

989

features = btrfs_super_incompat_flags(fs_info->super_copy);

fs/btrfs/tree-checker.c

996

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

175

struct btrfs_fs_info *fs_info = wc->trans->fs_info;

fs/btrfs/tree-log.c

188

if (test_and_set_bit(BTRFS_FS_STATE_LOG_REPLAY_ABORTED, &fs_info->fs_state))

fs/btrfs/tree-log.c

194

btrfs_crit(fs_info,

fs/btrfs/tree-log.c

201

btrfs_crit(fs_info,

fs/btrfs/tree-log.c

212

btrfs_crit(fs_info,

fs/btrfs/tree-log.c

2883

root->fs_info->sectorsize);

fs/btrfs/tree-log.c

291

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tree-log.c

292

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/tree-log.c

293

const bool zoned = btrfs_is_zoned(fs_info);

fs/btrfs/tree-log.c

2959

struct btrfs_fs_info *fs_info = eb->fs_info;

fs/btrfs/tree-log.c

2976

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

fs/btrfs/tree-log.c

2978

btrfs_err(fs_info, "unable to find block group for %llu", eb->start);

fs/btrfs/tree-log.c

2979

btrfs_handle_fs_error(fs_info, -ENOENT, NULL);

fs/btrfs/tree-log.c

2985

bg->reserved -= fs_info->nodesize;

fs/btrfs/tree-log.c

2986

bg->space_info->bytes_reserved -= fs_info->nodesize;

fs/btrfs/tree-log.c

2999

struct btrfs_fs_info *fs_info = wc->log->fs_info;

fs/btrfs/tree-log.c

3024

next = btrfs_find_create_tree_block(fs_info, bytenr,

fs/btrfs/tree-log.c

303

if (!fs_info->log_root_tree) {

fs/btrfs/tree-log.c

3032

btrfs_handle_fs_error(fs_info, ret, NULL);

fs/btrfs/tree-log.c

304

ret = btrfs_init_log_root_tree(trans, fs_info);

fs/btrfs/tree-log.c

3051

btrfs_handle_fs_error(fs_info, ret, NULL);

fs/btrfs/tree-log.c

3070

btrfs_handle_fs_error(fs_info, ret, NULL);

fs/btrfs/tree-log.c

3181

struct btrfs_fs_info *fs_info = log->fs_info;

fs/btrfs/tree-log.c

3186

ret = btrfs_insert_root(trans, fs_info->log_root_tree,

fs/btrfs/tree-log.c

3189

ret = btrfs_update_root(trans, fs_info->log_root_tree,

fs/btrfs/tree-log.c

3266

ctx->scratch_eb = alloc_dummy_extent_buffer(inode->root->fs_info, 0);

fs/btrfs/tree-log.c

3325

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tree-log.c

3327

struct btrfs_root *log_root_tree = fs_info->log_root_tree;

fs/btrfs/tree-log.c

3359

if (!btrfs_test_opt(fs_info, SSD) &&

fs/btrfs/tree-log.c

3386

ret = btrfs_write_marked_extents(fs_info, &log->dirty_log_pages, mark);

fs/btrfs/tree-log.c

3396

if (ret == -EAGAIN && btrfs_is_zoned(fs_info))

fs/btrfs/tree-log.c

3431

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/tree-log.c

3432

mutex_lock(&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

3441

mutex_unlock(&fs_info->tree_root->log_mutex);

fs/btrfs/tree-log.c

3463

btrfs_err(fs_info,

fs/btrfs/tree-log.c

3511

ret = btrfs_write_marked_extents(fs_info,

fs/btrfs/tree-log.c

3520

if (ret == -EAGAIN && btrfs_is_zoned(fs_info)) {

fs/btrfs/tree-log.c

3560

mutex_lock(&fs_info->tree_log_mutex);

fs/btrfs/tree-log.c

3569

if (BTRFS_FS_ERROR(fs_info)) {

fs/btrfs/tree-log.c

3573

mutex_unlock(&fs_info->tree_log_mutex);

fs/btrfs/tree-log.c

3577

btrfs_set_super_log_root(fs_info->super_for_commit, log_root_start);

fs/btrfs/tree-log.c

3578

btrfs_set_super_log_root_level(fs_info->super_for_commit, log_root_level);

fs/btrfs/tree-log.c

3579

ret = write_all_supers(fs_info, 1);

fs/btrfs/tree-log.c

3580

mutex_unlock(&fs_info->tree_log_mutex);

fs/btrfs/tree-log.c

3651

&log->fs_info->fs_state);

fs/btrfs/tree-log.c

3661

btrfs_write_marked_extents(log->fs_info,

fs/btrfs/tree-log.c

3670

btrfs_handle_fs_error(log->fs_info, ret, NULL);

fs/btrfs/tree-log.c

3695

struct btrfs_fs_info *fs_info)

fs/btrfs/tree-log.c

3697

if (fs_info->log_root_tree) {

fs/btrfs/tree-log.c

3698

free_log_tree(trans, fs_info->log_root_tree);

fs/btrfs/tree-log.c

3699

fs_info->log_root_tree = NULL;

fs/btrfs/tree-log.c

3700

clear_bit(BTRFS_ROOT_HAS_LOG_TREE, &fs_info->tree_root->state);

fs/btrfs/tree-log.c

377

const bool zoned = btrfs_is_zoned(root->fs_info);

fs/btrfs/tree-log.c

429

struct btrfs_fs_info *fs_info = log->fs_info;

fs/btrfs/tree-log.c

436

if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {

fs/btrfs/tree-log.c

447

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

5113

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

fs/btrfs/tree-log.c

5115

btrfs_err(trans->fs_info,

fs/btrfs/tree-log.c

5616

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tree-log.c

5623

if (!btrfs_fs_incompat(fs_info, NO_HOLES) || i_size == 0)

fs/btrfs/tree-log.c

5692

hole_len = ALIGN(i_size - prev_extent_end, fs_info->sectorsize);

fs/btrfs/tree-log.c

6552

const int leaf_data_size = BTRFS_LEAF_DATA_SIZE(trans->fs_info);

fs/btrfs/tree-log.c

722

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tree-log.c

748

extent_end = ALIGN(start + nbytes, fs_info->sectorsize);

fs/btrfs/tree-log.c

7545

struct btrfs_fs_info *fs_info = root->fs_info;

fs/btrfs/tree-log.c

7549

if (btrfs_test_opt(fs_info, NOTREELOG))

fs/btrfs/tree-log.c

7690

struct btrfs_fs_info *fs_info = log_root_tree->fs_info;

fs/btrfs/tree-log.c

7700

set_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags);

fs/btrfs/tree-log.c

7702

trans = btrfs_start_transaction(fs_info->tree_root, 0);

fs/btrfs/tree-log.c

7752

wc.root = btrfs_get_fs_root(fs_info, found_key.offset, true);

fs/btrfs/tree-log.c

7853

clear_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags);

fs/btrfs/tree-log.c

7860

clear_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags);

fs/btrfs/tree-log.c

825

btrfs_fs_incompat(fs_info, NO_HOLES))

fs/btrfs/tree-log.c

878

ret = btrfs_lookup_data_extent(fs_info, ins.objectid, ins.offset);

fs/btrfs/tree-log.c

986

csum_root = btrfs_csum_root(fs_info, sums->logical);

fs/btrfs/tree-log.c

988

btrfs_err(fs_info,

fs/btrfs/tree-log.h

63

WRITE_ONCE(trans->fs_info->last_trans_log_full_commit, trans->transid);

fs/btrfs/tree-log.h

68

return READ_ONCE(trans->fs_info->last_trans_log_full_commit) ==

fs/btrfs/tree-log.h

76

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

1048

btrfs_warn(fs_info,

fs/btrfs/tree-mod-log.c

1066

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

1081

eb = alloc_dummy_extent_buffer(fs_info, logical);

fs/btrfs/tree-mod-log.c

1101

tree_mod_log_rewind(fs_info, eb, time_seq, tm);

fs/btrfs/tree-mod-log.c

1104

WARN_ON(btrfs_header_nritems(eb) > BTRFS_NODEPTRS_PER_BLOCK(fs_info));

fs/btrfs/tree-mod-log.c

1133

u64 btrfs_tree_mod_log_lowest_seq(struct btrfs_fs_info *fs_info)

fs/btrfs/tree-mod-log.c

1137

read_lock(&fs_info->tree_mod_log_lock);

fs/btrfs/tree-mod-log.c

1138

if (!list_empty(&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

1141

elem = list_first_entry(&fs_info->tree_mod_seq_list,

fs/btrfs/tree-mod-log.c

1145

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

122

btrfs_warn(fs_info,

fs/btrfs/uuid-tree.c

136

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/uuid-tree.c

137

struct btrfs_root *uuid_root = fs_info->uuid_root;

fs/btrfs/uuid-tree.c

160

btrfs_warn(fs_info, "error %d while searching for uuid item!",

fs/btrfs/uuid-tree.c

172

btrfs_warn(fs_info, "uuid item with illegal size %lu!",

fs/btrfs/uuid-tree.c

209

int btrfs_uuid_tree_check_overflow(struct btrfs_fs_info *fs_info,

fs/btrfs/uuid-tree.c

217

if (WARN_ON_ONCE(!fs_info->uuid_root))

fs/btrfs/uuid-tree.c

225

ret = btrfs_search_slot(NULL, fs_info->uuid_root, &key, path, 0, 0);

fs/btrfs/uuid-tree.c

234

BTRFS_LEAF_DATA_SIZE(fs_info))

fs/btrfs/uuid-tree.c

264

static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info,

fs/btrfs/uuid-tree.c

274

subvol_root = btrfs_get_fs_root(fs_info, subvolid, true);

fs/btrfs/uuid-tree.c

298

int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info)

fs/btrfs/uuid-tree.c

300

struct btrfs_root *root = fs_info->uuid_root;

fs/btrfs/uuid-tree.c

325

if (btrfs_fs_closing(fs_info))

fs/btrfs/uuid-tree.c

340

btrfs_warn(fs_info,

fs/btrfs/uuid-tree.c

355

ret = btrfs_check_uuid_tree_entry(fs_info, uuid,

fs/btrfs/uuid-tree.c

396

struct btrfs_fs_info *fs_info = data;

fs/btrfs/uuid-tree.c

397

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/uuid-tree.c

419

if (btrfs_fs_closing(fs_info)) {

fs/btrfs/uuid-tree.c

459

trans = btrfs_start_transaction(fs_info->uuid_root, 2);

fs/btrfs/uuid-tree.c

475

btrfs_warn(fs_info, "uuid_tree_add failed %d",

fs/btrfs/uuid-tree.c

487

btrfs_warn(fs_info, "uuid_tree_add failed %d",

fs/btrfs/uuid-tree.c

522

btrfs_warn(fs_info, "btrfs_uuid_scan_kthread failed %d", ret);

fs/btrfs/uuid-tree.c

524

set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);

fs/btrfs/uuid-tree.c

525

up(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/uuid-tree.c

529

int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/uuid-tree.c

532

struct btrfs_root *tree_root = fs_info->tree_root;

fs/btrfs/uuid-tree.c

553

fs_info->uuid_root = uuid_root;

fs/btrfs/uuid-tree.c

559

down(&fs_info->uuid_tree_rescan_sem);

fs/btrfs/uuid-tree.c

560

task = kthread_run(btrfs_uuid_scan_kthread, fs_info, "btrfs-uuid");

fs/btrfs/uuid-tree.c

563

btrfs_warn(fs_info, "failed to start uuid_scan task");

fs/btrfs/uuid-tree.c

564

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

1161

device->fs_info = NULL;

fs/btrfs/volumes.c

1201

fs_devices->fs_info = NULL;

fs/btrfs/volumes.c

1532

lockdep_assert_held(&device->fs_info->chunk_mutex);

fs/btrfs/volumes.c

1577

lockdep_assert_held(&device->fs_info->chunk_mutex);

fs/btrfs/volumes.c

1811

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/volumes.c

1812

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/volumes.c

1952

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/volumes.c

1953

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/volumes.c

2000

static u64 find_next_chunk(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

2005

read_lock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

2006

n = rb_last(&fs_info->mapping_tree.rb_root);

fs/btrfs/volumes.c

2013

read_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

2018

static noinline int find_next_devid(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

2034

ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0);

fs/btrfs/volumes.c

2040

btrfs_err(fs_info, "corrupted chunk tree devid -1 matched");

fs/btrfs/volumes.c

2044

ret = btrfs_previous_item(fs_info->chunk_root, path,

fs/btrfs/volumes.c

2080

ret = btrfs_insert_empty_item(trans, trans->fs_info->chunk_root, path,

fs/btrfs/volumes.c

2107

write_extent_buffer(leaf, trans->fs_info->fs_devices->metadata_uuid,

fs/btrfs/volumes.c

2132

struct btrfs_root *root = device->fs_info->chunk_root;

fs/btrfs/volumes.c

2161

static int btrfs_check_raid_min_devices(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

2169

seq = read_seqbegin(&fs_info->profiles_lock);

fs/btrfs/volumes.c

2171

all_avail = fs_info->avail_data_alloc_bits |

fs/btrfs/volumes.c

2172

fs_info->avail_system_alloc_bits |

fs/btrfs/volumes.c

2173

fs_info->avail_metadata_alloc_bits;

fs/btrfs/volumes.c

2174

} while (read_seqretry(&fs_info->profiles_lock, seq));

fs/btrfs/volumes.c

2211

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/volumes.c

2214

next_device = btrfs_find_next_active_device(fs_info->fs_devices,

fs/btrfs/volumes.c

2218

if (fs_info->sb->s_bdev &&

fs/btrfs/volumes.c

2219

(fs_info->sb->s_bdev == device->bdev))

fs/btrfs/volumes.c

2220

fs_info->sb->s_bdev = next_device->bdev;

fs/btrfs/volumes.c

2222

if (fs_info->fs_devices->latest_dev->bdev == device->bdev)

fs/btrfs/volumes.c

2223

fs_info->fs_devices->latest_dev = next_device;

fs/btrfs/volumes.c

2230

static u64 btrfs_num_devices(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

2232

u64 num_devices = fs_info->fs_devices->num_devices;

fs/btrfs/volumes.c

2234

down_read(&fs_info->dev_replace.rwsem);

fs/btrfs/volumes.c

2235

if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) {

fs/btrfs/volumes.c

2239

up_read(&fs_info->dev_replace.rwsem);

fs/btrfs/volumes.c

2244

static void btrfs_scratch_superblock(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

2262

btrfs_warn(fs_info, "error clearing superblock number %d (%d)",

fs/btrfs/volumes.c

2266

void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info, struct btrfs_device *device)

fs/btrfs/volumes.c

2278

btrfs_scratch_superblock(fs_info, bdev, copy_num);

fs/btrfs/volumes.c

2288

int btrfs_rm_device(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

2295

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

2299

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/volumes.c

2300

btrfs_err(fs_info, "device remove not supported on extent tree v2 yet");

fs/btrfs/volumes.c

2309

num_devices = btrfs_num_devices(fs_info);

fs/btrfs/volumes.c

2311

ret = btrfs_check_raid_min_devices(fs_info, num_devices - 1);

fs/btrfs/volumes.c

2315

device = btrfs_find_device(fs_info->fs_devices, args);

fs/btrfs/volumes.c

2324

if (btrfs_pinned_by_swapfile(fs_info, device)) {

fs/btrfs/volumes.c

2325

btrfs_warn(fs_info,

fs/btrfs/volumes.c

2335

fs_info->fs_devices->rw_devices == 1)

fs/btrfs/volumes.c

2339

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2342

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2349

trans = btrfs_start_transaction(fs_info->chunk_root, 0);

fs/btrfs/volumes.c

2358

btrfs_crit(fs_info,

fs/btrfs/volumes.c

2405

num_devices = btrfs_super_num_devices(fs_info->super_copy) - 1;

fs/btrfs/volumes.c

2406

btrfs_set_super_num_devices(fs_info->super_copy, num_devices);

fs/btrfs/volumes.c

2420

btrfs_scratch_superblocks(fs_info, device);

fs/btrfs/volumes.c

2449

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2453

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2462

lockdep_assert_held(&srcdev->fs_info->fs_devices->device_list_mutex);

fs/btrfs/volumes.c

2514

struct btrfs_fs_devices *fs_devices = tgtdev->fs_info->fs_devices;

fs/btrfs/volumes.c

2531

btrfs_scratch_superblocks(tgtdev->fs_info, tgtdev);

fs/btrfs/volumes.c

2556

int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

2587

if (btrfs_fs_incompat(fs_info, METADATA_UUID))

fs/btrfs/volumes.c

261

static int btrfs_relocate_sys_chunks(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.c

2610

struct btrfs_fs_info *fs_info, u64 devid,

fs/btrfs/volumes.c

2619

device = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

2625

ret = btrfs_get_dev_args_from_path(fs_info, &args, device_path);

fs/btrfs/volumes.c

2628

device = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

2635

static struct btrfs_fs_devices *btrfs_init_sprout(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

2637

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

2680

static void btrfs_setup_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

2684

struct btrfs_super_block *disk_super = fs_info->super_copy;

fs/btrfs/volumes.c

2735

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

2736

struct btrfs_root *root = fs_info->chunk_root;

fs/btrfs/volumes.c

2789

device = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

2802

int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path)

fs/btrfs/volumes.c

2804

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/volumes.c

2808

struct super_block *sb = fs_info->sb;

fs/btrfs/volumes.c

2809

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

2821

fs_info->sb, &fs_holder_ops);

fs/btrfs/volumes.c

2825

if (!btrfs_check_device_zone_type(fs_info, file_bdev(bdev_file))) {

fs/btrfs/volumes.c

2854

device = btrfs_alloc_device(fs_info, NULL, NULL, device_path);

fs/btrfs/volumes.c

2861

device->fs_info = fs_info;

fs/btrfs/volumes.c

2880

device->io_width = fs_info->sectorsize;

fs/btrfs/volumes.c

2881

device->io_align = fs_info->sectorsize;

fs/btrfs/volumes.c

2882

device->sector_size = fs_info->sectorsize;

fs/btrfs/volumes.c

2884

round_down(bdev_nr_bytes(device->bdev), fs_info->sectorsize);

fs/btrfs/volumes.c

2894

seed_devices = btrfs_init_sprout(fs_info);

fs/btrfs/volumes.c

2904

btrfs_setup_sprout(fs_info, seed_devices);

fs/btrfs/volumes.c

2905

btrfs_assign_next_active_device(fs_info->fs_devices->latest_dev,

fs/btrfs/volumes.c

2911

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2920

atomic64_add(device->total_bytes, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

2925

orig_super_total_bytes = btrfs_super_total_bytes(fs_info->super_copy);

fs/btrfs/volumes.c

2926

btrfs_set_super_total_bytes(fs_info->super_copy,

fs/btrfs/volumes.c

2928

fs_info->sectorsize));

fs/btrfs/volumes.c

2930

orig_super_num_devices = btrfs_super_num_devices(fs_info->super_copy);

fs/btrfs/volumes.c

2931

btrfs_set_super_num_devices(fs_info->super_copy,

fs/btrfs/volumes.c

2938

btrfs_clear_space_info_full(fs_info);

fs/btrfs/volumes.c

2940

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2948

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2950

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

2987

ret = btrfs_relocate_sys_chunks(fs_info);

fs/btrfs/volumes.c

2989

btrfs_handle_fs_error(fs_info, ret,

fs/btrfs/volumes.c

3018

mutex_lock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/volumes.c

3019

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3022

fs_info->fs_devices->num_devices--;

fs/btrfs/volumes.c

3023

fs_info->fs_devices->open_devices--;

fs/btrfs/volumes.c

3024

fs_info->fs_devices->rw_devices--;

fs/btrfs/volumes.c

3025

fs_info->fs_devices->total_devices--;

fs/btrfs/volumes.c

3026

fs_info->fs_devices->total_rw_bytes -= device->total_bytes;

fs/btrfs/volumes.c

3027

atomic64_sub(device->total_bytes, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

3028

btrfs_set_super_total_bytes(fs_info->super_copy,

fs/btrfs/volumes.c

3030

btrfs_set_super_num_devices(fs_info->super_copy,

fs/btrfs/volumes.c

3032

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3033

mutex_unlock(&fs_info->fs_devices->device_list_mutex);

fs/btrfs/volumes.c

3054

struct btrfs_root *root = device->fs_info->chunk_root;

fs/btrfs/volumes.c

3092

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/volumes.c

3093

struct btrfs_super_block *super_copy = fs_info->super_copy;

fs/btrfs/volumes.c

3101

new_size = round_down(new_size, fs_info->sectorsize);

fs/btrfs/volumes.c

3103

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3105

diff = round_down(new_size - device->total_bytes, fs_info->sectorsize);

fs/btrfs/volumes.c

3109

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3114

round_down(old_total + diff, fs_info->sectorsize));

fs/btrfs/volumes.c

3116

atomic64_add(diff, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

3120

btrfs_clear_space_info_full(device->fs_info);

fs/btrfs/volumes.c

3124

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3135

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

3136

struct btrfs_root *root = fs_info->chunk_root;

fs/btrfs/volumes.c

3154

btrfs_err(fs_info, "failed to lookup chunk %llu when freeing",

fs/btrfs/volumes.c

3162

btrfs_err(fs_info, "failed to delete chunk %llu item", chunk_offset);

fs/btrfs/volumes.c

3169

static int btrfs_del_sys_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset)

fs/btrfs/volumes.c

3171

struct btrfs_super_block *super_copy = fs_info->super_copy;

fs/btrfs/volumes.c

3182

lockdep_assert_held(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3215

struct btrfs_chunk_map *btrfs_find_chunk_map_nolock(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

3218

struct rb_node *node = fs_info->mapping_tree.rb_root.rb_node;

fs/btrfs/volumes.c

3278

struct btrfs_chunk_map *btrfs_find_chunk_map(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

3283

read_lock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

3284

map = btrfs_find_chunk_map_nolock(fs_info, logical, length);

fs/btrfs/volumes.c

3285

read_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

3298

struct btrfs_chunk_map *btrfs_get_chunk_map(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

3303

map = btrfs_find_chunk_map(fs_info, logical, length);

fs/btrfs/volumes.c

3306

btrfs_crit(fs_info,

fs/btrfs/volumes.c

3313

btrfs_crit(fs_info,

fs/btrfs/volumes.c

3335

lockdep_assert_held(&trans->fs_info->chunk_mutex);

fs/btrfs/volumes.c

3350

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

3351

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

3378

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3381

atomic64_add(dev_extent_len, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

3382

btrfs_clear_space_info_full(fs_info);

fs/btrfs/volumes.c

3389

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3399

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

3403

map = btrfs_get_chunk_map(fs_info, chunk_offset, 1);

fs/btrfs/volumes.c

3436

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3456

const u64 sys_flags = btrfs_system_alloc_profile(fs_info);

fs/btrfs/volumes.c

3460

space_info = btrfs_find_space_info(fs_info, sys_flags);

fs/btrfs/volumes.c

3490

trace_btrfs_chunk_free(fs_info, map, chunk_offset, map->chunk_len);

fs/btrfs/volumes.c

3493

ret = btrfs_del_sys_chunk(fs_info, chunk_offset);

fs/btrfs/volumes.c

3500

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3512

ASSERT(BTRFS_FS_ERROR(fs_info) != 0);

fs/btrfs/volumes.c

3516

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

3524

static int btrfs_relocate_chunk_finish(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

3527

struct btrfs_root *root = fs_info->chunk_root;

fs/btrfs/volumes.c

3532

btrfs_discard_cancel_work(&fs_info->discard_ctl, bg);

fs/btrfs/volumes.c

3542

if (btrfs_is_zoned(fs_info)) {

fs/btrfs/volumes.c

3543

ret = btrfs_discard_extent(fs_info, bg->start, length, NULL, true);

fs/btrfs/volumes.c

3545

btrfs_info(fs_info, "failed to reset zone %llu after relocation",

fs/btrfs/volumes.c

3549

trans = btrfs_start_trans_remove_block_group(root->fs_info, bg->start);

fs/btrfs/volumes.c

3552

btrfs_handle_fs_error(root->fs_info, ret, NULL);

fs/btrfs/volumes.c

3563

int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset, bool verbose)

fs/btrfs/volumes.c

3568

if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {

fs/btrfs/volumes.c

3569

btrfs_err(fs_info,

fs/btrfs/volumes.c

3586

lockdep_assert_held(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

3589

btrfs_scrub_pause(fs_info);

fs/btrfs/volumes.c

3590

ret = btrfs_relocate_block_group(fs_info, chunk_offset, verbose);

fs/btrfs/volumes.c

3591

btrfs_scrub_continue(fs_info);

fs/btrfs/volumes.c

3597

if (BTRFS_FS_ERROR(fs_info))

fs/btrfs/volumes.c

3598

btrfs_scrub_cancel(fs_info);

fs/btrfs/volumes.c

3602

block_group = btrfs_lookup_block_group(fs_info, chunk_offset);

fs/btrfs/volumes.c

3611

ret = btrfs_relocate_chunk_finish(fs_info, block_group);

fs/btrfs/volumes.c

3617

static int btrfs_relocate_sys_chunks(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

3619

struct btrfs_root *chunk_root = fs_info->chunk_root;

fs/btrfs/volumes.c

3640

mutex_lock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

3643

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

3654

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

3661

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

3676

ret = btrfs_relocate_chunk(fs_info, found_key.offset,

fs/btrfs/volumes.c

3683

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

3705

static int btrfs_may_alloc_data_chunk(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

3712

cache = btrfs_lookup_block_group(fs_info, chunk_offset);

fs/btrfs/volumes.c

3720

spin_lock(&fs_info->data_sinfo->lock);

fs/btrfs/volumes.c

3721

bytes_used = fs_info->data_sinfo->bytes_used;

fs/btrfs/volumes.c

3722

spin_unlock(&fs_info->data_sinfo->lock);

fs/btrfs/volumes.c

3728

trans = btrfs_join_transaction(fs_info->tree_root);

fs/btrfs/volumes.c

3780

static int insert_balance_item(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

3783

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/volumes.c

3833

static int del_balance_item(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

3835

struct btrfs_root *root = fs_info->tree_root;

fs/btrfs/volumes.c

3920

static void reset_balance_state(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

3922

struct btrfs_balance_control *bctl = fs_info->balance_ctl;

fs/btrfs/volumes.c

3925

ASSERT(fs_info->balance_ctl);

fs/btrfs/volumes.c

3927

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

3928

fs_info->balance_ctl = NULL;

fs/btrfs/volumes.c

3929

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

3932

ret = del_balance_item(fs_info);

fs/btrfs/volumes.c

3934

btrfs_handle_fs_error(fs_info, ret, NULL);

fs/btrfs/volumes.c

3952

static bool chunk_usage_range_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,

fs/btrfs/volumes.c

3961

cache = btrfs_lookup_block_group(fs_info, chunk_offset);

fs/btrfs/volumes.c

3983

static bool chunk_usage_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,

fs/btrfs/volumes.c

3990

cache = btrfs_lookup_block_group(fs_info, chunk_offset);

fs/btrfs/volumes.c

4109

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/volumes.c

4110

struct btrfs_balance_control *bctl = fs_info->balance_ctl;

fs/btrfs/volumes.c

4141

chunk_usage_filter(fs_info, chunk_offset, bargs)) {

fs/btrfs/volumes.c

4144

chunk_usage_range_filter(fs_info, chunk_offset, bargs)) {

fs/btrfs/volumes.c

4210

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

4214

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, 0, 1);

fs/btrfs/volumes.c

4219

ret = btrfs_next_leaf(fs_info->remap_root, path);

fs/btrfs/volumes.c

4231

ret = btrfs_search_slot(trans, fs_info->remap_root, &key, path, 0, 1);

fs/btrfs/volumes.c

4239

static int balance_remap_chunks(struct btrfs_fs_info *fs_info, struct btrfs_path *path,

fs/btrfs/volumes.c

4247

rci->bg = btrfs_lookup_block_group(fs_info, rci->offset);

fs/btrfs/volumes.c

4264

trans = btrfs_start_transaction(fs_info->remap_root, 0);

fs/btrfs/volumes.c

4270

mutex_lock(&fs_info->remap_mutex);

fs/btrfs/volumes.c

4272

mutex_unlock(&fs_info->remap_mutex);

fs/btrfs/volumes.c

4311

static int __btrfs_balance(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

4313

struct btrfs_balance_control *bctl = fs_info->balance_ctl;

fs/btrfs/volumes.c

4314

struct btrfs_root *chunk_root = fs_info->chunk_root;

fs/btrfs/volumes.c

4344

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4346

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4362

if ((!counting && atomic_read(&fs_info->balance_pause_req)) ||

fs/btrfs/volumes.c

4363

atomic_read(&fs_info->balance_cancel_req)) {

fs/btrfs/volumes.c

4368

mutex_lock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4371

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4380

btrfs_err(fs_info,

fs/btrfs/volumes.c

4383

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4391

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4401

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4412

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4417

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4419

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4426

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4431

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4432

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4434

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4457

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4466

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4491

ret = btrfs_may_alloc_data_chunk(fs_info,

fs/btrfs/volumes.c

4494

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4501

ret = btrfs_relocate_chunk(fs_info, found_key.offset, true);

fs/btrfs/volumes.c

4502

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

4506

btrfs_info(fs_info,

fs/btrfs/volumes.c

4513

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4515

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4531

ret = balance_remap_chunks(fs_info, path, &remap_chunks);

fs/btrfs/volumes.c

4536

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4538

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4543

btrfs_info(fs_info, "%d enospc errors during balance",

fs/btrfs/volumes.c

4580

static inline int validate_convert_profile(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

4592

btrfs_err(fs_info, "balance: invalid convert %s profile %s",

fs/btrfs/volumes.c

4695

static void describe_balance_start_or_resume(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

4703

struct btrfs_balance_control *bctl = fs_info->balance_ctl;

fs/btrfs/volumes.c

4744

btrfs_info(fs_info, "balance: %s %s",

fs/btrfs/volumes.c

4752

int btrfs_balance(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

4766

if (btrfs_fs_closing(fs_info) ||

fs/btrfs/volumes.c

4767

atomic_read(&fs_info->balance_pause_req) ||

fs/btrfs/volumes.c

4768

btrfs_should_cancel_balance(fs_info)) {

fs/btrfs/volumes.c

4773

allowed = btrfs_super_incompat_flags(fs_info->super_copy);

fs/btrfs/volumes.c

4786

btrfs_err(fs_info,

fs/btrfs/volumes.c

4797

num_devices = fs_info->fs_devices->rw_devices;

fs/btrfs/volumes.c

4809

if (!validate_convert_profile(fs_info, &bctl->data, allowed, "data") ||

fs/btrfs/volumes.c

4810

!validate_convert_profile(fs_info, &bctl->meta, allowed, "metadata") ||

fs/btrfs/volumes.c

4811

!validate_convert_profile(fs_info, &bctl->sys, allowed, "system")) {

fs/btrfs/volumes.c

4827

seq = read_seqbegin(&fs_info->profiles_lock);

fs/btrfs/volumes.c

4830

(fs_info->avail_system_alloc_bits & allowed) &&

fs/btrfs/volumes.c

4833

(fs_info->avail_metadata_alloc_bits & allowed) &&

fs/btrfs/volumes.c

4841

bctl->meta.target : fs_info->avail_metadata_alloc_bits;

fs/btrfs/volumes.c

4843

bctl->data.target : fs_info->avail_data_alloc_bits;

fs/btrfs/volumes.c

4844

} while (read_seqretry(&fs_info->profiles_lock, seq));

fs/btrfs/volumes.c

4848

btrfs_info(fs_info,

fs/btrfs/volumes.c

4851

btrfs_err(fs_info,

fs/btrfs/volumes.c

4860

btrfs_warn(fs_info,

fs/btrfs/volumes.c

4866

ret = insert_balance_item(fs_info, bctl);

fs/btrfs/volumes.c

4872

BUG_ON(fs_info->balance_ctl);

fs/btrfs/volumes.c

4873

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4874

fs_info->balance_ctl = bctl;

fs/btrfs/volumes.c

4875

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4878

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4880

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4883

ASSERT(!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags));

fs/btrfs/volumes.c

4884

set_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags);

fs/btrfs/volumes.c

4885

describe_balance_start_or_resume(fs_info);

fs/btrfs/volumes.c

4886

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

4888

ret = __btrfs_balance(fs_info);

fs/btrfs/volumes.c

4890

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

4891

if (ret == -ECANCELED && atomic_read(&fs_info->balance_pause_req)) {

fs/btrfs/volumes.c

4892

btrfs_info(fs_info, "balance: paused");

fs/btrfs/volumes.c

4893

btrfs_exclop_balance(fs_info, BTRFS_EXCLOP_BALANCE_PAUSED);

fs/btrfs/volumes.c

4912

btrfs_info(fs_info, "balance: canceled");

fs/btrfs/volumes.c

4914

btrfs_info(fs_info, "balance: ended with status: %d", ret);

fs/btrfs/volumes.c

4916

clear_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags);

fs/btrfs/volumes.c

4920

btrfs_update_ioctl_balance_args(fs_info, bargs);

fs/btrfs/volumes.c

4925

reset_balance_state(fs_info);

fs/btrfs/volumes.c

4926

btrfs_exclop_finish(fs_info);

fs/btrfs/volumes.c

4929

wake_up(&fs_info->balance_wait_q);

fs/btrfs/volumes.c

4934

reset_balance_state(fs_info);

fs/btrfs/volumes.c

4937

btrfs_exclop_finish(fs_info);

fs/btrfs/volumes.c

4944

struct btrfs_fs_info *fs_info = data;

fs/btrfs/volumes.c

4947

guard(super_write)(fs_info->sb);

fs/btrfs/volumes.c

4949

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

4950

if (fs_info->balance_ctl)

fs/btrfs/volumes.c

4951

ret = btrfs_balance(fs_info, fs_info->balance_ctl, NULL);

fs/btrfs/volumes.c

4952

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

4957

int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

4961

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

4962

if (!fs_info->balance_ctl) {

fs/btrfs/volumes.c

4963

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

4966

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

4968

if (btrfs_test_opt(fs_info, SKIP_BALANCE)) {

fs/btrfs/volumes.c

4969

btrfs_info(fs_info, "balance: resume skipped");

fs/btrfs/volumes.c

4973

spin_lock(&fs_info->super_lock);

fs/btrfs/volumes.c

4974

ASSERT(fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED,

fs/btrfs/volumes.c

4975

"exclusive_operation=%d", fs_info->exclusive_operation);

fs/btrfs/volumes.c

4976

fs_info->exclusive_operation = BTRFS_EXCLOP_BALANCE;

fs/btrfs/volumes.c

4977

spin_unlock(&fs_info->super_lock);

fs/btrfs/volumes.c

4983

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4984

fs_info->balance_ctl->flags |= BTRFS_BALANCE_RESUME;

fs/btrfs/volumes.c

4985

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

4987

tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance");

fs/btrfs/volumes.c

4991

int btrfs_recover_balance(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

5009

ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);

fs/btrfs/volumes.c

5043

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE_PAUSED))

fs/btrfs/volumes.c

5044

btrfs_warn(fs_info,

fs/btrfs/volumes.c

5049

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5050

BUG_ON(fs_info->balance_ctl);

fs/btrfs/volumes.c

5051

spin_lock(&fs_info->balance_lock);

fs/btrfs/volumes.c

5052

fs_info->balance_ctl = bctl;

fs/btrfs/volumes.c

5053

spin_unlock(&fs_info->balance_lock);

fs/btrfs/volumes.c

5054

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5058

int btrfs_pause_balance(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

5062

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5063

if (!fs_info->balance_ctl) {

fs/btrfs/volumes.c

5064

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5068

if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) {

fs/btrfs/volumes.c

5069

atomic_inc(&fs_info->balance_pause_req);

fs/btrfs/volumes.c

5070

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5072

wait_event(fs_info->balance_wait_q,

fs/btrfs/volumes.c

5073

!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags));

fs/btrfs/volumes.c

5075

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5077

BUG_ON(test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags));

fs/btrfs/volumes.c

5078

atomic_dec(&fs_info->balance_pause_req);

fs/btrfs/volumes.c

5083

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5087

int btrfs_cancel_balance(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

5089

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5090

if (!fs_info->balance_ctl) {

fs/btrfs/volumes.c

5091

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5100

if (sb_rdonly(fs_info->sb)) {

fs/btrfs/volumes.c

5101

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5105

atomic_inc(&fs_info->balance_cancel_req);

fs/btrfs/volumes.c

5110

if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) {

fs/btrfs/volumes.c

5111

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5112

wait_event(fs_info->balance_wait_q,

fs/btrfs/volumes.c

5113

!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags));

fs/btrfs/volumes.c

5114

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5116

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5121

mutex_lock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5123

if (fs_info->balance_ctl) {

fs/btrfs/volumes.c

5124

reset_balance_state(fs_info);

fs/btrfs/volumes.c

5125

btrfs_exclop_finish(fs_info);

fs/btrfs/volumes.c

5126

btrfs_info(fs_info, "balance: canceled");

fs/btrfs/volumes.c

5130

ASSERT(!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags));

fs/btrfs/volumes.c

5131

atomic_dec(&fs_info->balance_cancel_req);

fs/btrfs/volumes.c

5132

mutex_unlock(&fs_info->balance_mutex);

fs/btrfs/volumes.c

5143

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/volumes.c

5144

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/volumes.c

5156

struct btrfs_super_block *super_copy = fs_info->super_copy;

fs/btrfs/volumes.c

5164

new_size = round_down(new_size, fs_info->sectorsize);

fs/btrfs/volumes.c

5166

diff = round_down(old_size - new_size, fs_info->sectorsize);

fs/btrfs/volumes.c

5183

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5200

atomic64_sub(free_diff, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

5209

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5214

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5224

mutex_lock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5227

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5233

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5246

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5255

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5269

ret = btrfs_may_alloc_data_chunk(fs_info, chunk_offset);

fs/btrfs/volumes.c

5271

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5275

ret = btrfs_relocate_chunk(fs_info, chunk_offset, true);

fs/btrfs/volumes.c

5276

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

5281

btrfs_warn(fs_info,

fs/btrfs/volumes.c

5305

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5317

round_down(old_total - diff, fs_info->sectorsize));

fs/btrfs/volumes.c

5318

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5333

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5337

atomic64_add(free_diff, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

5339

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5344

static int btrfs_add_system_chunk(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

5348

struct btrfs_super_block *super_copy = fs_info->super_copy;

fs/btrfs/volumes.c

5353

lockdep_assert_held(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5445

space_info = btrfs_find_space_info(fs_devices->fs_info, ctl->type);

fs/btrfs/volumes.c

5464

u64 zone_size = fs_devices->fs_info->zone_size;

fs/btrfs/volumes.c

5502

ctl->devs_max = BTRFS_MAX_DEVS(fs_devices->fs_info);

fs/btrfs/volumes.c

5526

struct btrfs_fs_info *info = fs_devices->fs_info;

fs/btrfs/volumes.c

5686

struct btrfs_fs_info *info = fs_devices->fs_info;

fs/btrfs/volumes.c

5741

void btrfs_remove_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map)

fs/btrfs/volumes.c

5743

write_lock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

5744

rb_erase_cached(&map->rb_node, &fs_info->mapping_tree);

fs/btrfs/volumes.c

5747

write_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

5769

int btrfs_add_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map)

fs/btrfs/volumes.c

5773

write_lock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

5774

exist = rb_find_add_cached(&map->rb_node, &fs_info->mapping_tree,

fs/btrfs/volumes.c

5778

write_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

5783

write_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

5807

struct btrfs_fs_info *info = trans->fs_info;

fs/btrfs/volumes.c

5874

struct btrfs_fs_info *info = trans->fs_info;

fs/btrfs/volumes.c

5931

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

5932

struct btrfs_root *chunk_root = fs_info->chunk_root;

fs/btrfs/volumes.c

5963

lockdep_assert_held(&fs_info->chunk_mutex);

fs/btrfs/volumes.c

5965

map = btrfs_get_chunk_map(fs_info, bg->start, bg->length);

fs/btrfs/volumes.c

6007

btrfs_set_stack_chunk_sector_size(chunk, fs_info->sectorsize);

fs/btrfs/volumes.c

6021

ret = btrfs_add_system_chunk(fs_info, &key, chunk, item_size);

fs/btrfs/volumes.c

6034

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

6062

alloc_profile = btrfs_metadata_alloc_profile(fs_info);

fs/btrfs/volumes.c

6063

meta_space_info = btrfs_find_space_info(fs_info, alloc_profile);

fs/btrfs/volumes.c

6072

alloc_profile = btrfs_system_alloc_profile(fs_info);

fs/btrfs/volumes.c

6073

sys_space_info = btrfs_find_space_info(fs_info, alloc_profile);

fs/btrfs/volumes.c

6092

bool btrfs_chunk_writeable(struct btrfs_fs_info *fs_info, u64 chunk_offset)

fs/btrfs/volumes.c

6099

map = btrfs_get_chunk_map(fs_info, chunk_offset, 1);

fs/btrfs/volumes.c

6127

void btrfs_mapping_tree_free(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

6129

write_lock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

6130

while (!RB_EMPTY_ROOT(&fs_info->mapping_tree.rb_root)) {

fs/btrfs/volumes.c

6134

node = rb_first_cached(&fs_info->mapping_tree);

fs/btrfs/volumes.c

6136

rb_erase_cached(&map->rb_node, &fs_info->mapping_tree);

fs/btrfs/volumes.c

6141

cond_resched_rwlock_write(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

6143

write_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

6167

int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len)

fs/btrfs/volumes.c

6172

map = btrfs_get_chunk_map(fs_info, logical, len);

fs/btrfs/volumes.c

6187

unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6191

unsigned long len = fs_info->sectorsize;

fs/btrfs/volumes.c

6193

if (!btrfs_fs_incompat(fs_info, RAID56))

fs/btrfs/volumes.c

6196

map = btrfs_get_chunk_map(fs_info, logical, len);

fs/btrfs/volumes.c

6254

struct btrfs_fs_info *fs_info = device->fs_devices->fs_info;

fs/btrfs/volumes.c

6259

total_reads = percpu_counter_sum(&fs_info->stats_read_blocks);

fs/btrfs/volumes.c

6260

min_reads_per_dev = READ_ONCE(fs_info->fs_devices->rr_min_contig_read) >>

fs/btrfs/volumes.c

6261

fs_info->sectorsize_bits;

fs/btrfs/volumes.c

6276

static int find_live_mirror(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6280

const enum btrfs_read_policy policy = READ_ONCE(fs_info->fs_devices->read_policy);

fs/btrfs/volumes.c

6298

btrfs_warn_rl(fs_info, "unknown read_policy type %u, reset to pid",

fs/btrfs/volumes.c

6300

WRITE_ONCE(fs_info->fs_devices->read_policy, BTRFS_READ_POLICY_PID);

fs/btrfs/volumes.c

6316

fs_info->dev_replace.cont_reading_from_srcdev_mode ==

fs/btrfs/volumes.c

6318

srcdev = fs_info->dev_replace.srcdev;

fs/btrfs/volumes.c

6345

struct btrfs_io_context *alloc_btrfs_io_context(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6357

bioc->fs_info = fs_info;

fs/btrfs/volumes.c

6383

struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6405

map = btrfs_get_chunk_map(fs_info, logical, length);

fs/btrfs/volumes.c

6412

ret = btrfs_translate_remap(fs_info, &new_logical, &length);

fs/btrfs/volumes.c

6419

map = btrfs_get_chunk_map(fs_info, new_logical, length);

fs/btrfs/volumes.c

6538

static bool is_block_group_to_copy(struct btrfs_fs_info *fs_info, u64 logical)

fs/btrfs/volumes.c

6544

if (!btrfs_is_zoned(fs_info))

fs/btrfs/volumes.c

6547

cache = btrfs_lookup_block_group(fs_info, logical);

fs/btrfs/volumes.c

6574

if (is_block_group_to_copy(dev_replace->srcdev->fs_info, logical))

fs/btrfs/volumes.c

6683

static int set_io_stripe(struct btrfs_fs_info *fs_info, u64 logical,

fs/btrfs/volumes.c

6691

return btrfs_get_raid_extent_offset(fs_info, logical, length,

fs/btrfs/volumes.c

6701

static bool is_single_device_io(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6731

static void map_blocks_raid1(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6746

io_geom->stripe_index = find_live_mirror(fs_info, map, 0,

fs/btrfs/volumes.c

6767

static void map_blocks_raid10(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

6789

io_geom->stripe_index = find_live_mirror(fs_info, map,

fs/btrfs/volumes.c

6887

int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,

fs/btrfs/volumes.c

6898

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/volumes.c

6910

map = btrfs_get_chunk_map(fs_info, logical, *length);

fs/btrfs/volumes.c

6917

ret = btrfs_translate_remap(fs_info, &new_logical, length);

fs/btrfs/volumes.c

6924

map = btrfs_get_chunk_map(fs_info, new_logical, *length);

fs/btrfs/volumes.c

6942

io_geom.use_rst = btrfs_need_stripe_tree_update(fs_info, map->type);

fs/btrfs/volumes.c

6962

map_blocks_raid1(fs_info, map, &io_geom, dev_replace_is_ongoing);

fs/btrfs/volumes.c

6968

map_blocks_raid10(fs_info, map, &io_geom, dev_replace_is_ongoing);

fs/btrfs/volumes.c

6987

btrfs_crit(fs_info,

fs/btrfs/volumes.c

7011

if (is_single_device_io(fs_info, smap, map, num_alloc_stripes, &io_geom)) {

fs/btrfs/volumes.c

7012

ret = set_io_stripe(fs_info, logical, length, smap, map, &io_geom);

fs/btrfs/volumes.c

7019

bioc = alloc_btrfs_io_context(fs_info, logical, num_alloc_stripes);

fs/btrfs/volumes.c

7064

ret = set_io_stripe(fs_info, logical, length,

fs/btrfs/volumes.c

7206

struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7213

if (WARN_ON(!devid && !fs_info))

fs/btrfs/volumes.c

7226

btrfs_extent_io_tree_init(fs_info, &dev->alloc_state, IO_TREE_DEVICE_ALLOC_STATE);

fs/btrfs/volumes.c

7233

ret = find_next_devid(fs_info, &tmp);

fs/btrfs/volumes.c

7260

static void btrfs_report_missing_device(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7264

btrfs_err_rl(fs_info, "devid %llu uuid %pU is missing",

fs/btrfs/volumes.c

7267

btrfs_warn_rl(fs_info, "devid %llu uuid %pU is missing",

fs/btrfs/volumes.c

7286

static int check_32bit_meta_chunk(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7295

btrfs_err_32bit_limit(fs_info);

fs/btrfs/volumes.c

7305

static void warn_32bit_meta_chunk(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7314

btrfs_warn_32bit_limit(fs_info);

fs/btrfs/volumes.c

7318

static struct btrfs_device *handle_missing_device(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7323

if (!btrfs_test_opt(fs_info, DEGRADED)) {

fs/btrfs/volumes.c

7324

btrfs_report_missing_device(fs_info, devid, uuid, true);

fs/btrfs/volumes.c

7328

dev = add_missing_dev(fs_info->fs_devices, devid, uuid);

fs/btrfs/volumes.c

7330

btrfs_err(fs_info, "failed to init missing device %llu: %ld",

fs/btrfs/volumes.c

7334

btrfs_report_missing_device(fs_info, devid, uuid, false);

fs/btrfs/volumes.c

7343

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/volumes.c

7362

ret = check_32bit_meta_chunk(fs_info, logical, length, type);

fs/btrfs/volumes.c

7365

warn_32bit_meta_chunk(fs_info, logical, length, type);

fs/btrfs/volumes.c

7368

map = btrfs_find_chunk_map(fs_info, logical, 1);

fs/btrfs/volumes.c

7413

map->stripes[i].dev = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

7415

map->stripes[i].dev = handle_missing_device(fs_info,

fs/btrfs/volumes.c

7428

ret = btrfs_add_chunk_map(fs_info, map);

fs/btrfs/volumes.c

7430

btrfs_err(fs_info,

fs/btrfs/volumes.c

7462

static struct btrfs_fs_devices *open_seed_devices(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7472

list_for_each_entry(fs_devices, &fs_info->fs_devices->seed_list, seed_list)

fs/btrfs/volumes.c

7479

if (!btrfs_test_opt(fs_info, DEGRADED)) {

fs/btrfs/volumes.c

7480

btrfs_err(fs_info,

fs/btrfs/volumes.c

7492

list_add(&fs_devices->seed_list, &fs_info->fs_devices->seed_list);

fs/btrfs/volumes.c

7504

ret = open_fs_devices(fs_devices, BLK_OPEN_READ, fs_info->sb);

fs/btrfs/volumes.c

7516

list_add(&fs_devices->seed_list, &fs_info->fs_devices->seed_list);

fs/btrfs/volumes.c

7525

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/volumes.c

7526

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

7542

fs_devices = open_seed_devices(fs_info, fs_uuid);

fs/btrfs/volumes.c

7547

device = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

7549

if (!btrfs_test_opt(fs_info, DEGRADED)) {

fs/btrfs/volumes.c

7550

btrfs_report_missing_device(fs_info, devid,

fs/btrfs/volumes.c

7557

btrfs_err(fs_info,

fs/btrfs/volumes.c

7562

btrfs_report_missing_device(fs_info, devid, dev_uuid, false);

fs/btrfs/volumes.c

7565

if (!btrfs_test_opt(fs_info, DEGRADED)) {

fs/btrfs/volumes.c

7566

btrfs_report_missing_device(fs_info,

fs/btrfs/volumes.c

7570

btrfs_report_missing_device(fs_info, devid,

fs/btrfs/volumes.c

7602

if (device->fs_devices != fs_info->fs_devices) {

fs/btrfs/volumes.c

7614

btrfs_err(fs_info,

fs/btrfs/volumes.c

7626

&fs_info->free_chunk_space);

fs/btrfs/volumes.c

7632

int btrfs_read_sys_array(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

7634

struct btrfs_super_block *super_copy = fs_info->super_copy;

fs/btrfs/volumes.c

7643

ASSERT(BTRFS_SUPER_INFO_SIZE <= fs_info->nodesize);

fs/btrfs/volumes.c

7650

sb = alloc_dummy_extent_buffer(fs_info, BTRFS_SUPER_INFO_OFFSET);

fs/btrfs/volumes.c

7709

bool btrfs_check_rw_degradable(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

7716

map = btrfs_find_chunk_map(fs_info, 0, U64_MAX);

fs/btrfs/volumes.c

7741

btrfs_warn(fs_info,

fs/btrfs/volumes.c

7750

map = btrfs_find_chunk_map(fs_info, next_start, U64_MAX - next_start);

fs/btrfs/volumes.c

7765

int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

7767

struct btrfs_root *root = fs_info->chunk_root;

fs/btrfs/volumes.c

7794

fs_info->fs_devices->total_rw_bytes = 0;

fs/btrfs/volumes.c

7806

ASSERT(!test_bit(BTRFS_FS_OPEN, &fs_info->flags));

fs/btrfs/volumes.c

7865

if (total_dev != fs_info->fs_devices->total_devices) {

fs/btrfs/volumes.c

7866

btrfs_warn(fs_info,

fs/btrfs/volumes.c

7868

btrfs_super_num_devices(fs_info->super_copy),

fs/btrfs/volumes.c

7870

fs_info->fs_devices->total_devices = total_dev;

fs/btrfs/volumes.c

7871

btrfs_set_super_num_devices(fs_info->super_copy, total_dev);

fs/btrfs/volumes.c

7873

if (btrfs_super_total_bytes(fs_info->super_copy) <

fs/btrfs/volumes.c

7874

fs_info->fs_devices->total_rw_bytes) {

fs/btrfs/volumes.c

7875

btrfs_err(fs_info,

fs/btrfs/volumes.c

7877

btrfs_super_total_bytes(fs_info->super_copy),

fs/btrfs/volumes.c

7878

fs_info->fs_devices->total_rw_bytes);

fs/btrfs/volumes.c

7888

int btrfs_init_devices_late(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

7890

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;

fs/btrfs/volumes.c

7896

device->fs_info = fs_info;

fs/btrfs/volumes.c

7900

device->fs_info = fs_info;

fs/btrfs/volumes.c

7906

seed_devs->fs_info = fs_info;

fs/btrfs/volumes.c

7945

if (!device->fs_info->dev_root)

fs/btrfs/volumes.c

7951

ret = btrfs_search_slot(NULL, device->fs_info->dev_root, &key, path, 0, 0);

fs/btrfs/volumes.c

7980

int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

7982

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;

fs/btrfs/volumes.c

8012

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

8013

struct btrfs_root *dev_root = fs_info->dev_root;

fs/btrfs/volumes.c

8030

btrfs_warn(fs_info,

fs/btrfs/volumes.c

8041

btrfs_warn(fs_info,

fs/btrfs/volumes.c

8055

btrfs_warn(fs_info,

fs/btrfs/volumes.c

8075

struct btrfs_fs_info *fs_info = trans->fs_info;

fs/btrfs/volumes.c

8076

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

8117

btrfs_err_rl(dev->fs_info,

fs/btrfs/volumes.c

8137

btrfs_info(dev->fs_info,

fs/btrfs/volumes.c

8147

int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

8152

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/volumes.c

8157

dev = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

8161

btrfs_warn(fs_info, "get dev_stats failed, device not found");

fs/btrfs/volumes.c

8164

btrfs_warn(fs_info, "get dev_stats failed, not yet valid");

fs/btrfs/volumes.c

8174

btrfs_info(fs_info, "device stats zeroed by %s (%d)",

fs/btrfs/volumes.c

8207

mutex_lock(&trans->fs_info->chunk_mutex);

fs/btrfs/volumes.c

8214

mutex_unlock(&trans->fs_info->chunk_mutex);

fs/btrfs/volumes.c

8227

static int verify_one_dev_extent(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

8239

map = btrfs_find_chunk_map(fs_info, chunk_offset, 1);

fs/btrfs/volumes.c

8241

btrfs_err(fs_info,

fs/btrfs/volumes.c

8250

btrfs_err(fs_info,

fs/btrfs/volumes.c

8264

btrfs_warn(fs_info,

fs/btrfs/volumes.c

8273

btrfs_err(fs_info,

fs/btrfs/volumes.c

8284

btrfs_err(fs_info,

fs/btrfs/volumes.c

8291

dev = btrfs_find_device(fs_info->fs_devices, &args);

fs/btrfs/volumes.c

8293

btrfs_err(fs_info, "failed to find devid %llu", devid);

fs/btrfs/volumes.c

8299

btrfs_err(fs_info,

fs/btrfs/volumes.c

8312

btrfs_err(fs_info,

fs/btrfs/volumes.c

8325

static int verify_chunk_dev_extent_mapping(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

8330

read_lock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

8331

for (node = rb_first_cached(&fs_info->mapping_tree); node; node = rb_next(node)) {

fs/btrfs/volumes.c

8336

btrfs_err(fs_info,

fs/btrfs/volumes.c

8344

read_unlock(&fs_info->mapping_tree_lock);

fs/btrfs/volumes.c

8355

int btrfs_verify_dev_extents(struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

8358

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/volumes.c

8374

if (btrfs_test_opt(fs_info, IGNOREBADROOTS))

fs/btrfs/volumes.c

8419

btrfs_err(fs_info,

fs/btrfs/volumes.c

8425

ret = verify_one_dev_extent(fs_info, chunk_offset, devid,

fs/btrfs/volumes.c

8442

return verify_chunk_dev_extent_mapping(fs_info);

fs/btrfs/volumes.c

8452

bool btrfs_verify_dev_items(const struct btrfs_fs_info *fs_info)

fs/btrfs/volumes.c

8459

list_for_each_entry(dev, &fs_info->fs_devices->devices, dev_list) {

fs/btrfs/volumes.c

8461

btrfs_err(fs_info,

fs/btrfs/volumes.c

8467

list_for_each_entry(seed_devs, &fs_info->fs_devices->seed_list, seed_list) {

fs/btrfs/volumes.c

8470

btrfs_err(fs_info,

fs/btrfs/volumes.c

8479

btrfs_err(fs_info,

fs/btrfs/volumes.c

8488

bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr)

fs/btrfs/volumes.c

8493

spin_lock(&fs_info->swapfile_pins_lock);

fs/btrfs/volumes.c

8494

node = fs_info->swapfile_pins.rb_node;

fs/btrfs/volumes.c

8504

spin_unlock(&fs_info->swapfile_pins_lock);

fs/btrfs/volumes.c

8511

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/volumes.c

8518

guard(super_write)(fs_info->sb);

fs/btrfs/volumes.c

8520

if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE)) {

fs/btrfs/volumes.c

8521

btrfs_info(fs_info,

fs/btrfs/volumes.c

8527

mutex_lock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

8530

cache = btrfs_lookup_block_group(fs_info, target);

fs/btrfs/volumes.c

8537

ret = btrfs_may_alloc_data_chunk(fs_info, target);

fs/btrfs/volumes.c

8541

btrfs_info(fs_info,

fs/btrfs/volumes.c

8544

ret = btrfs_relocate_chunk(fs_info, target, true);

fs/btrfs/volumes.c

8549

mutex_unlock(&fs_info->reclaim_bgs_lock);

fs/btrfs/volumes.c

8550

btrfs_exclop_finish(fs_info);

fs/btrfs/volumes.c

8555

bool btrfs_repair_one_zone(struct btrfs_fs_info *fs_info, u64 logical)

fs/btrfs/volumes.c

8559

if (!btrfs_is_zoned(fs_info))

fs/btrfs/volumes.c

8563

if (btrfs_test_opt(fs_info, DEGRADED))

fs/btrfs/volumes.c

8566

cache = btrfs_lookup_block_group(fs_info, logical);

fs/btrfs/volumes.c

8616

int btrfs_map_repair_block(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.c

8627

ret = btrfs_map_block(fs_info, BTRFS_MAP_WRITE, logical, &map_length,

fs/btrfs/volumes.h

126

struct btrfs_fs_info *fs_info;

fs/btrfs/volumes.h

439

struct btrfs_fs_info *fs_info;

fs/btrfs/volumes.h

505

struct btrfs_fs_info *fs_info;

fs/btrfs/volumes.h

710

int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,

fs/btrfs/volumes.h

714

int btrfs_map_repair_block(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

717

struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

720

int btrfs_read_sys_array(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

721

int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

725

void btrfs_mapping_tree_free(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

734

struct btrfs_device *btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

737

int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

740

struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

744

int btrfs_rm_device(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

748

int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);

fs/btrfs/volumes.h

754

int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *path);

fs/btrfs/volumes.h

755

int btrfs_balance(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

759

int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

760

int btrfs_recover_balance(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

761

int btrfs_pause_balance(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

762

int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset,

fs/btrfs/volumes.h

764

int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

765

bool btrfs_chunk_writeable(struct btrfs_fs_info *fs_info, u64 chunk_offset);

fs/btrfs/volumes.h

767

int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

769

int btrfs_init_devices_late(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

770

int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

775

unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

786

int btrfs_add_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map);

fs/btrfs/volumes.h

789

struct btrfs_chunk_map *btrfs_find_chunk_map(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

791

struct btrfs_chunk_map *btrfs_find_chunk_map_nolock(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

793

struct btrfs_chunk_map *btrfs_get_chunk_map(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

795

void btrfs_remove_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map);

fs/btrfs/volumes.h

881

bool btrfs_check_rw_degradable(struct btrfs_fs_info *fs_info,

fs/btrfs/volumes.h

883

void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info, struct btrfs_device *device);

fs/btrfs/volumes.h

888

int btrfs_verify_dev_extents(struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

889

bool btrfs_verify_dev_items(const struct btrfs_fs_info *fs_info);

fs/btrfs/volumes.h

890

bool btrfs_repair_one_zone(struct btrfs_fs_info *fs_info, u64 logical);

fs/btrfs/volumes.h

892

bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr);

fs/btrfs/volumes.h

903

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

151

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/zlib.c

157

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/zlib.c

163

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/zlib.c

168

btrfs_err(fs_info,

fs/btrfs/zlib.c

178

out_folio = btrfs_alloc_compr_folio(fs_info);

fs/btrfs/zlib.c

204

if (need_special_buffer(fs_info)) {

fs/btrfs/zlib.c

235

btrfs_warn(fs_info,

fs/btrfs/zlib.c

261

out_folio = btrfs_alloc_compr_folio(fs_info);

fs/btrfs/zlib.c

299

out_folio = btrfs_alloc_compr_folio(fs_info);

fs/btrfs/zlib.c

346

struct btrfs_fs_info *fs_info = cb_to_fs_info(cb);

fs/btrfs/zlib.c

349

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

389

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

432

btrfs_err(cb->bbio.inode->root->fs_info,

fs/btrfs/zlib.c

478

btrfs_err(inode->root->fs_info,

fs/btrfs/zlib.c

500

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

74

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/zlib.c

87

if (need_special_buffer(fs_info)) {

fs/btrfs/zoned.c

1208

device->fs_info,

fs/btrfs/zoned.c

1231

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/zoned.c

1263

root = btrfs_extent_root(fs_info, key.objectid);

fs/btrfs/zoned.c

1265

btrfs_err(fs_info,

fs/btrfs/zoned.c

1292

length = fs_info->nodesize;

fs/btrfs/zoned.c

1308

static int btrfs_load_zone_info(struct btrfs_fs_info *fs_info, int zone_idx,

fs/btrfs/zoned.c

1312

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/zoned.c

1354

WARN_ON(!IS_ALIGNED(info->physical, fs_info->zone_size));

fs/btrfs/zoned.c

1379

btrfs_err(fs_info,

fs/btrfs/zoned.c

1392

btrfs_err(fs_info,

fs/btrfs/zoned.c

1421

btrfs_err(bg->fs_info,

fs/btrfs/zoned.c

1440

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.c

1442

if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {

fs/btrfs/zoned.c

1443

btrfs_err(fs_info, "zoned: data DUP profile needs raid-stripe-tree");

fs/btrfs/zoned.c

1450

btrfs_err(fs_info,

fs/btrfs/zoned.c

1456

btrfs_err(fs_info,

fs/btrfs/zoned.c

1483

btrfs_err(fs_info,

fs/btrfs/zoned.c

1505

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.c

1508

if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {

fs/btrfs/zoned.c

1509

btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",

fs/btrfs/zoned.c

1540

!btrfs_test_opt(fs_info, DEGRADED))) {

fs/btrfs/zoned.c

1541

btrfs_err(fs_info,

fs/btrfs/zoned.c

1547

if (unlikely(!btrfs_test_opt(fs_info, DEGRADED) &&

fs/btrfs/zoned.c

1571

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.c

1577

if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {

fs/btrfs/zoned.c

1578

btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",

fs/btrfs/zoned.c

1637

btrfs_err(fs_info,

fs/btrfs/zoned.c

1645

btrfs_err(fs_info,

fs/btrfs/zoned.c

1670

btrfs_err(fs_info, "zoned: stripe gap too large in block group %llu", bg->start);

fs/btrfs/zoned.c

1675

btrfs_err(fs_info, "zoned: allocated extent stays beyond write pointers %llu %llu",

fs/btrfs/zoned.c

1689

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.c

1696

if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {

fs/btrfs/zoned.c

1697

btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",

fs/btrfs/zoned.c

1724

btrfs_err(fs_info,

fs/btrfs/zoned.c

1735

btrfs_err(fs_info,

fs/btrfs/zoned.c

1781

btrfs_err(fs_info,

fs/btrfs/zoned.c

1789

btrfs_err(fs_info,

fs/btrfs/zoned.c

1821

btrfs_err(fs_info, "zoned: stripe gap too large in block group %llu",

fs/btrfs/zoned.c

1827

btrfs_err(fs_info, "zoned: allocated extent stays beyond write pointers %llu %llu",

fs/btrfs/zoned.c

1841

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.c

1867

btrfs_err(fs_info, "zoned: profile %s not yet supported",

fs/btrfs/zoned.c

1893

struct btrfs_fs_info *fs_info = cache->fs_info;

fs/btrfs/zoned.c

1904

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

1908

if (unlikely(!IS_ALIGNED(length, fs_info->zone_size))) {

fs/btrfs/zoned.c

1909

btrfs_err(fs_info,

fs/btrfs/zoned.c

1911

logical, length, fs_info->zone_size);

fs/btrfs/zoned.c

1915

map = btrfs_find_chunk_map(fs_info, logical, length);

fs/btrfs/zoned.c

1934

ret = btrfs_load_zone_info(fs_info, i, &zone_info[i], active, map, new);

fs/btrfs/zoned.c

1950

btrfs_err(fs_info,

fs/btrfs/zoned.c

1968

!fs_info->stripe_root) {

fs/btrfs/zoned.c

1969

btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",

fs/btrfs/zoned.c

1975

btrfs_err(fs_info,

fs/btrfs/zoned.c

1984

btrfs_err(fs_info,

fs/btrfs/zoned.c

1994

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

1996

&fs_info->zone_active_bgs);

fs/btrfs/zoned.c

1997

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2012

if (!btrfs_is_zoned(cache->fs_info))

fs/btrfs/zoned.c

202

const sector_t zone_sectors = device->fs_info->zone_size >> SECTOR_SHIFT;

fs/btrfs/zoned.c

2030

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/zoned.c

2034

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2054

cache = btrfs_lookup_block_group(fs_info, start);

fs/btrfs/zoned.c

2115

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/zoned.c

2140

btrfs_err(fs_info, "failed to split ordered extent");

fs/btrfs/zoned.c

2158

test_bit(BTRFS_FS_STATE_NO_DATA_CSUMS, &fs_info->fs_state)) {

fs/btrfs/zoned.c

2172

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/zoned.c

2177

if (fs_info->treelog_bg == block_group->start) {

fs/btrfs/zoned.c

2179

int ret_fin = btrfs_zone_finish_one_bg(fs_info);

fs/btrfs/zoned.c

2188

lockdep_assert_held(&fs_info->zoned_meta_io_lock);

fs/btrfs/zoned.c

2202

btrfs_zoned_meta_io_unlock(fs_info);

fs/btrfs/zoned.c

2205

btrfs_zoned_meta_io_lock(fs_info);

fs/btrfs/zoned.c

2231

int btrfs_check_meta_write_pointer(struct btrfs_fs_info *fs_info,

fs/btrfs/zoned.c

2238

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2251

block_group = btrfs_lookup_block_group(fs_info, eb->start);

fs/btrfs/zoned.c

2260

if (!test_bit(BTRFS_FS_ACTIVE_ZONE_TRACKING, &fs_info->flags))

fs/btrfs/zoned.c

2264

tgt = &fs_info->active_system_bg;

fs/btrfs/zoned.c

2266

tgt = &fs_info->active_meta_bg;

fs/btrfs/zoned.c

2293

static int read_zone_info(struct btrfs_fs_info *fs_info, u64 logical,

fs/btrfs/zoned.c

2302

ret = btrfs_map_block(fs_info, BTRFS_MAP_GET_READ_MIRRORS, logical,

fs/btrfs/zoned.c

2344

struct btrfs_fs_info *fs_info = tgt_dev->fs_info;

fs/btrfs/zoned.c

2353

ret = read_zone_info(fs_info, logical, &zone);

fs/btrfs/zoned.c

2378

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/zoned.c

2386

if (!btrfs_is_zoned(block_group->fs_info))

fs/btrfs/zoned.c

2391

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2449

list_add_tail(&block_group->active_bg_list, &fs_info->zone_active_bgs);

fs/btrfs/zoned.c

2450

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2456

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2462

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/zoned.c

2465

unsigned long index, start = (block_group->start >> fs_info->nodesize_bits);

fs/btrfs/zoned.c

2468

xa_for_each_start(&fs_info->buffer_tree, index, eb, start) {

fs/btrfs/zoned.c

2516

struct btrfs_fs_info *fs_info = block_group->fs_info;

fs/btrfs/zoned.c

2520

struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;

fs/btrfs/zoned.c

2558

btrfs_wait_ordered_roots(fs_info, U64_MAX, block_group);

fs/btrfs/zoned.c

2610

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2613

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2618

clear_and_wake_up_bit(BTRFS_FS_NEED_ZONE_FINISH, &fs_info->flags);

fs/btrfs/zoned.c

2625

if (!btrfs_is_zoned(block_group->fs_info))

fs/btrfs/zoned.c

2633

struct btrfs_fs_info *fs_info = fs_devices->fs_info;

fs/btrfs/zoned.c

2637

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2640

if (test_bit(BTRFS_FS_NEED_ZONE_FINISH, &fs_info->flags))

fs/btrfs/zoned.c

2644

mutex_lock(&fs_info->chunk_mutex);

fs/btrfs/zoned.c

2645

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2672

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

2673

mutex_unlock(&fs_info->chunk_mutex);

fs/btrfs/zoned.c

2676

set_bit(BTRFS_FS_NEED_ZONE_FINISH, &fs_info->flags);

fs/btrfs/zoned.c

2681

int btrfs_zone_finish_endio(struct btrfs_fs_info *fs_info, u64 logical, u64 length)

fs/btrfs/zoned.c

2686

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2689

block_group = btrfs_lookup_block_group(fs_info, logical);

fs/btrfs/zoned.c

2695

min_alloc_bytes = fs_info->sectorsize;

fs/btrfs/zoned.c

2697

min_alloc_bytes = fs_info->nodesize;

fs/btrfs/zoned.c

272

btrfs_err(device->fs_info,

fs/btrfs/zoned.c

2721

btrfs_handle_fs_error(bg->fs_info, ret,

fs/btrfs/zoned.c

2734

btrfs_err(bg->fs_info, "double scheduling of bg %llu zone finishing",

fs/btrfs/zoned.c

2749

struct btrfs_fs_info *fs_info = bg->fs_info;

fs/btrfs/zoned.c

2751

spin_lock(&fs_info->relocation_bg_lock);

fs/btrfs/zoned.c

2752

if (fs_info->data_reloc_bg == bg->start)

fs/btrfs/zoned.c

2753

fs_info->data_reloc_bg = 0;

fs/btrfs/zoned.c

2754

spin_unlock(&fs_info->relocation_bg_lock);

fs/btrfs/zoned.c

2757

void btrfs_zoned_reserve_data_reloc_bg(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

2759

struct btrfs_space_info *data_sinfo = fs_info->data_sinfo;

fs/btrfs/zoned.c

2770

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2773

if (fs_info->data_reloc_bg)

fs/btrfs/zoned.c

2776

if (sb_rdonly(fs_info->sb))

fs/btrfs/zoned.c

2779

alloc_flags = btrfs_get_alloc_profile(fs_info, space_info->flags);

fs/btrfs/zoned.c

2823

btrfs_add_bg_to_space_info(fs_info, bg);

fs/btrfs/zoned.c

2826

fs_info->data_reloc_bg = bg->start;

fs/btrfs/zoned.c

2836

trans = btrfs_join_transaction(fs_info->tree_root);

fs/btrfs/zoned.c

2857

void btrfs_free_zone_cache(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

2859

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/zoned.c

2862

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2875

bool btrfs_zoned_should_reclaim(const struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

2877

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/zoned.c

2879

u64 total = btrfs_super_total_bytes(fs_info->super_copy);

fs/btrfs/zoned.c

2883

ASSERT(btrfs_is_zoned(fs_info));

fs/btrfs/zoned.c

2885

if (fs_info->bg_reclaim_threshold == 0)

fs/btrfs/zoned.c

2898

return factor >= fs_info->bg_reclaim_threshold;

fs/btrfs/zoned.c

2901

void btrfs_zoned_release_data_reloc_bg(struct btrfs_fs_info *fs_info, u64 logical,

fs/btrfs/zoned.c

2906

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

2909

block_group = btrfs_lookup_block_group(fs_info, logical);

fs/btrfs/zoned.c

2932

int btrfs_zone_finish_one_bg(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

2939

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

294

static int calculate_emulated_zone_size(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

2940

list_for_each_entry(block_group, &fs_info->zone_active_bgs,

fs/btrfs/zoned.c

2962

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

297

struct btrfs_root *root = fs_info->dev_root;

fs/btrfs/zoned.c

2975

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/zoned.c

2979

if (!btrfs_is_zoned(fs_info) || (space_info->flags & BTRFS_BLOCK_GROUP_DATA))

fs/btrfs/zoned.c

3013

ret = btrfs_zone_finish_one_bg(fs_info);

fs/btrfs/zoned.c

3027

void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

3029

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/zoned.c

3037

if (!test_bit(BTRFS_FS_ACTIVE_ZONE_TRACKING, &fs_info->flags))

fs/btrfs/zoned.c

3044

if (fs_info->avail_metadata_alloc_bits & BTRFS_BLOCK_GROUP_DUP)

fs/btrfs/zoned.c

3046

if (fs_info->avail_system_alloc_bits & BTRFS_BLOCK_GROUP_DUP)

fs/btrfs/zoned.c

3061

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

3062

list_for_each_entry(block_group, &fs_info->zone_active_bgs, active_bg_list) {

fs/btrfs/zoned.c

3072

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

3092

struct btrfs_fs_info *fs_info = space_info->fs_info;

fs/btrfs/zoned.c

3093

const sector_t zone_size_sectors = fs_info->zone_size >> SECTOR_SHIFT;

fs/btrfs/zoned.c

3095

if (!btrfs_is_zoned(fs_info))

fs/btrfs/zoned.c

3112

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/zoned.c

3113

list_for_each_entry(bg, &fs_info->unused_bgs, bg_list) {

fs/btrfs/zoned.c

3134

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/zoned.c

3140

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/zoned.c

3148

down_read(&fs_info->dev_replace.rwsem);

fs/btrfs/zoned.c

3162

up_read(&fs_info->dev_replace.rwsem);

fs/btrfs/zoned.c

3166

up_read(&fs_info->dev_replace.rwsem);

fs/btrfs/zoned.c

3200

void btrfs_show_zoned_stats(struct btrfs_fs_info *fs_info, struct seq_file *seq)

fs/btrfs/zoned.c

3208

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

3210

list_count_nodes(&fs_info->zone_active_bgs));

fs/btrfs/zoned.c

3211

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

3213

spin_lock(&fs_info->unused_bgs_lock);

fs/btrfs/zoned.c

3215

list_count_nodes(&fs_info->reclaim_bgs));

fs/btrfs/zoned.c

3216

seq_printf(seq, "\t unused: %zu\n", list_count_nodes(&fs_info->unused_bgs));

fs/btrfs/zoned.c

3217

spin_unlock(&fs_info->unused_bgs_lock);

fs/btrfs/zoned.c

3220

str_true_false(btrfs_zoned_should_reclaim(fs_info)));

fs/btrfs/zoned.c

3222

data_reloc_bg = data_race(fs_info->data_reloc_bg);

fs/btrfs/zoned.c

3226

treelog_bg = data_race(fs_info->treelog_bg);

fs/btrfs/zoned.c

3230

spin_lock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

3232

list_for_each_entry(bg, &fs_info->zone_active_bgs, active_bg_list) {

fs/btrfs/zoned.c

3252

spin_unlock(&fs_info->zone_active_bgs_lock);

fs/btrfs/zoned.c

326

fs_info->zone_size = btrfs_dev_extent_length(leaf, dext);

fs/btrfs/zoned.c

330

int btrfs_get_dev_zone_info_all_devices(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

332

struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/zoned.c

337

if (!btrfs_fs_incompat(fs_info, ZONED))

fs/btrfs/zoned.c

359

struct btrfs_fs_info *fs_info = device->fs_info;

fs/btrfs/zoned.c

376

if (!btrfs_fs_incompat(fs_info, ZONED))

fs/btrfs/zoned.c

389

if (!fs_info->zone_size) {

fs/btrfs/zoned.c

390

ret = calculate_emulated_zone_size(fs_info);

fs/btrfs/zoned.c

395

ASSERT(fs_info->zone_size);

fs/btrfs/zoned.c

396

zone_sectors = fs_info->zone_size >> SECTOR_SHIFT;

fs/btrfs/zoned.c

406

btrfs_err(fs_info,

fs/btrfs/zoned.c

413

btrfs_err(fs_info,

fs/btrfs/zoned.c

432

btrfs_err(fs_info,

fs/btrfs/zoned.c

474

btrfs_err(device->fs_info,

fs/btrfs/zoned.c

512

btrfs_err(device->fs_info,

fs/btrfs/zoned.c

527

btrfs_err(device->fs_info,

fs/btrfs/zoned.c

536

set_bit(BTRFS_FS_ACTIVE_ZONE_TRACKING, &fs_info->flags);

fs/btrfs/zoned.c

559

btrfs_err(device->fs_info,

fs/btrfs/zoned.c

577

btrfs_err(device->fs_info,

fs/btrfs/zoned.c

596

btrfs_info(fs_info,

fs/btrfs/zoned.c

676

static int btrfs_check_for_zoned_device(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

680

list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) {

fs/btrfs/zoned.c

682

btrfs_err(fs_info,

fs/btrfs/zoned.c

692

int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info)

fs/btrfs/zoned.c

694

struct queue_limits *lim = &fs_info->limits;

fs/btrfs/zoned.c

703

if (!btrfs_fs_incompat(fs_info, ZONED))

fs/btrfs/zoned.c

704

return btrfs_check_for_zoned_device(fs_info);

fs/btrfs/zoned.c

708

list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) {

fs/btrfs/zoned.c

717

btrfs_err(fs_info,

fs/btrfs/zoned.c

734

btrfs_err(fs_info, "zoned: failed to validate queue limits");

fs/btrfs/zoned.c

744

btrfs_err(fs_info,

fs/btrfs/zoned.c

750

if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {

fs/btrfs/zoned.c

751

btrfs_err(fs_info, "zoned: mixed block groups not supported");

fs/btrfs/zoned.c

755

fs_info->zone_size = zone_size;

fs/btrfs/zoned.c

763

fs_info->max_zone_append_size = ALIGN_DOWN(

fs/btrfs/zoned.c

767

fs_info->sectorsize);

fs/btrfs/zoned.c

768

fs_info->fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_ZONED;

fs/btrfs/zoned.c

770

fs_info->max_extent_size = min_not_zero(fs_info->max_extent_size,

fs/btrfs/zoned.c

771

fs_info->max_zone_append_size);

fs/btrfs/zoned.c

777

ret = btrfs_check_mountopts_zoned(fs_info, &fs_info->mount_opt);

fs/btrfs/zoned.c

781

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

373

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/zstd.c

402

struct btrfs_fs_info *fs_info = inode->root->fs_info;

fs/btrfs/zstd.c

417

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/zstd.c

418

const u32 min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/zstd.c

425

btrfs_err(fs_info,

fs/btrfs/zstd.c

442

out_folio = btrfs_alloc_compr_folio(fs_info);

fs/btrfs/zstd.c

456

btrfs_warn(fs_info,

fs/btrfs/zstd.c

485

out_folio = btrfs_alloc_compr_folio(fs_info);

fs/btrfs/zstd.c

527

btrfs_err(fs_info,

fs/btrfs/zstd.c

558

out_folio = btrfs_alloc_compr_folio(fs_info);

fs/btrfs/zstd.c

587

struct btrfs_fs_info *fs_info = cb_to_fs_info(cb);

fs/btrfs/zstd.c

593

const u32 blocksize = fs_info->sectorsize;

fs/btrfs/zstd.c

594

const unsigned int min_folio_size = btrfs_min_folio_size(fs_info);

fs/btrfs/zstd.c

610

btrfs_err(inode->root->fs_info,

fs/btrfs/zstd.c

633

btrfs_err(inode->root->fs_info,

fs/btrfs/zstd.c

684

struct btrfs_fs_info *fs_info = btrfs_sb(folio_inode(dest_folio)->i_sb);

fs/btrfs/zstd.c

685

const u32 sectorsize = fs_info->sectorsize;

fs/btrfs/zstd.c

695

btrfs_err(inode->root->fs_info,

fs/btrfs/zstd.c

719

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

2291

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

1202

fs_info(sdp, "quota %s for %s %u\n",

fs/gfs2/quota.c

1501

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

680

fs_info(sdp, "GFS2: couldn't thaw filesystem: %d\n", error);

fs/gfs2/super.c

711

fs_info(sdp, "GFS2: couldn't freeze filesystem: %d\n", error);

fs/gfs2/super.c

742

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

297

fs_info(sdp, "GFS2:adding buf while withdrawn! 0x%llx\n",

fs/gfs2/trans.c

302

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

7281

void *fs_info)

fs/ocfs2/xattr.c

7283

struct ocfs2_security_xattr_info *si = fs_info;

fs/proc/base.c

2022

struct proc_fs_info *fs_info = proc_sb_info(inode->i_sb);

fs/proc/base.c

2032

if (!has_pid_permissions(fs_info, task, HIDEPID_INVISIBLE)) {

fs/proc/base.c

3508

struct proc_fs_info *fs_info;

fs/proc/base.c

3516

fs_info = proc_sb_info(dentry->d_sb);

fs/proc/base.c

3517

ns = fs_info->pid_ns;

fs/proc/base.c

3527

if (fs_info->hide_pid == HIDEPID_NOT_PTRACEABLE) {

fs/proc/base.c

3528

if (!has_pid_permissions(fs_info, task, HIDEPID_NO_ACCESS))

fs/proc/base.c

3576

struct proc_fs_info *fs_info = proc_sb_info(file_inode(file)->i_sb);

fs/proc/base.c

3602

if (!has_pid_permissions(fs_info, iter.task, HIDEPID_INVISIBLE))

fs/proc/base.c

3809

struct proc_fs_info *fs_info;

fs/proc/base.c

3820

fs_info = proc_sb_info(dentry->d_sb);

fs/proc/base.c

3821

ns = fs_info->pid_ns;

fs/proc/base.c

745

static bool has_pid_permissions(struct proc_fs_info *fs_info,

fs/proc/base.c

754

if (fs_info->hide_pid == HIDEPID_NOT_PTRACEABLE)

fs/proc/base.c

757

if (fs_info->hide_pid < hide_pid_min)

fs/proc/base.c

759

if (in_group_p(fs_info->pid_gid))

fs/proc/base.c

768

struct proc_fs_info *fs_info = proc_sb_info(inode->i_sb);

fs/proc/base.c

775

has_perms = has_pid_permissions(fs_info, task, HIDEPID_NO_ACCESS);

fs/proc/base.c

779

if (fs_info->hide_pid == HIDEPID_INVISIBLE) {

fs/proc/generic.c

270

struct proc_fs_info *fs_info = proc_sb_info(dir->i_sb);

fs/proc/generic.c

272

if (fs_info->pidonly == PROC_PIDONLY_ON)

fs/proc/generic.c

331

struct proc_fs_info *fs_info = proc_sb_info(inode->i_sb);

fs/proc/generic.c

333

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/root.c

226

static void proc_apply_options(struct proc_fs_info *fs_info,

fs/proc/root.c

233

fs_info->pid_gid = make_kgid(user_ns, ctx->gid);

fs/proc/root.c

235

fs_info->hide_pid = ctx->hidepid;

fs/proc/root.c

237

fs_info->pidonly = ctx->pidonly;

fs/proc/root.c

240

put_pid_ns(fs_info->pid_ns);

fs/proc/root.c

241

fs_info->pid_ns = get_pid_ns(ctx->pid_ns);

fs/proc/root.c

249

struct proc_fs_info *fs_info;

fs/proc/root.c

252

fs_info = kzalloc_obj(*fs_info);

fs/proc/root.c

253

if (!fs_info)

fs/proc/root.c

256

fs_info->pid_ns = get_pid_ns(ctx->pid_ns);

fs/proc/root.c

257

proc_apply_options(fs_info, fc, current_user_ns());

fs/proc/root.c

267

s->s_fs_info = fs_info;

fs/proc/root.c

302

struct proc_fs_info *fs_info = proc_sb_info(sb);

fs/proc/root.c

306

proc_apply_options(fs_info, fc, current_user_ns());

fs/proc/root.c

348

struct proc_fs_info *fs_info = proc_sb_info(sb);

fs/proc/root.c

351

if (fs_info) {

fs/proc/root.c

352

put_pid_ns(fs_info->pid_ns);

fs/proc/root.c

353

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

1003

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1007

TP_ARGS(fs_info, head_ref, action)

include/trace/events/btrfs.h

1012

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1016

TP_ARGS(fs_info, head_ref, action)

include/trace/events/btrfs.h

1033

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1036

TP_ARGS(fs_info, map, offset, size),

include/trace/events/btrfs.h

1047

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1053

__entry->root_objectid = btrfs_root_id(fs_info->chunk_root);

include/trace/events/btrfs.h

1067

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1070

TP_ARGS(fs_info, map, offset, size)

include/trace/events/btrfs.h

1075

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1078

TP_ARGS(fs_info, map, offset, size)

include/trace/events/btrfs.h

1097

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

1118

TP_PROTO(const struct btrfs_fs_info *fs_info, const char *type, u64 val,

include/trace/events/btrfs.h

1121

TP_ARGS(fs_info, type, val, bytes, reserve),

include/trace/events/btrfs.h

1130

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1144

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 bytes,

include/trace/events/btrfs.h

1147

TP_ARGS(fs_info, flags, bytes, flush, reason),

include/trace/events/btrfs.h

1156

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1175

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 num_bytes,

include/trace/events/btrfs.h

1178

TP_ARGS(fs_info, flags, num_bytes, state, ret, for_preempt),

include/trace/events/btrfs.h

1188

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1207

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),

include/trace/events/btrfs.h

1209

TP_ARGS(fs_info, start, len),

include/trace/events/btrfs.h

1216

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1229

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),

include/trace/events/btrfs.h

1231

TP_ARGS(fs_info, start, len)

include/trace/events/btrfs.h

1236

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),

include/trace/events/btrfs.h

1238

TP_ARGS(fs_info, start, len)

include/trace/events/btrfs.h

1255

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

1284

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

1318

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

1358

TP_fast_assign_btrfs(block_group->fs_info,

include/trace/events/btrfs.h

1411

TP_fast_assign_btrfs(block_group->fs_info,

include/trace/events/btrfs.h

1438

TP_fast_assign_btrfs(block_group->fs_info,

include/trace/events/btrfs.h

1462

TP_fast_assign_btrfs(block_group->fs_info,

include/trace/events/btrfs.h

1557

TP_PROTO(const struct btrfs_fs_info *fs_info, const void *wtag),

include/trace/events/btrfs.h

1559

TP_ARGS(fs_info, wtag),

include/trace/events/btrfs.h

1565

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1588

TP_PROTO(const struct btrfs_fs_info *fs_info, const void *wtag),

include/trace/events/btrfs.h

1590

TP_ARGS(fs_info, wtag)

include/trace/events/btrfs.h

163

#define TP_fast_assign_fsid(fs_info) \

include/trace/events/btrfs.h

165

if (fs_info) \

include/trace/events/btrfs.h

166

memcpy(__entry->fsid, fs_info->fs_devices->fsid, \

include/trace/events/btrfs.h

1706

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1710

TP_ARGS(fs_info, rec, bytenr),

include/trace/events/btrfs.h

1717

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1728

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1732

TP_ARGS(fs_info, rec, bytenr)

include/trace/events/btrfs.h

1737

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1741

TP_ARGS(fs_info, rec, bytenr)

include/trace/events/btrfs.h

1746

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 transid,

include/trace/events/btrfs.h

1749

TP_ARGS(fs_info, transid, num_dirty_extents),

include/trace/events/btrfs.h

1756

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

176

#define TP_fast_assign_btrfs(fs_info, args...) \

include/trace/events/btrfs.h

1767

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 transid, u64 bytenr,

include/trace/events/btrfs.h

1770

TP_ARGS(fs_info, transid, bytenr, num_bytes, nr_old_roots,

include/trace/events/btrfs.h

178

TP_fast_assign_fsid(fs_info); \

include/trace/events/btrfs.h

1781

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1800

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1804

TP_ARGS(fs_info, qgroup, cur_old_count, cur_new_count),

include/trace/events/btrfs.h

1814

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1829

TP_PROTO(const struct btrfs_fs_info *fs_info, const struct btrfs_qgroup *qgroup,

include/trace/events/btrfs.h

1832

TP_ARGS(fs_info, qgroup, diff, type),

include/trace/events/btrfs.h

1841

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

185

TP_PROTO(const struct btrfs_fs_info *fs_info),

include/trace/events/btrfs.h

1865

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

187

TP_ARGS(fs_info),

include/trace/events/btrfs.h

1887

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

1911

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

1925

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1928

TP_ARGS(fs_info, oldref, newref, tree_size),

include/trace/events/btrfs.h

194

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

1943

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

195

__entry->generation = fs_info->generation;

include/trace/events/btrfs.h

1968

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1971

TP_ARGS(fs_info, oldref, newref, tree_size)

include/trace/events/btrfs.h

1975

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

1978

TP_ARGS(fs_info, oldref, newref, tree_size)

include/trace/events/btrfs.h

1993

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

2017

TP_fast_assign_btrfs(bg_cache->fs_info,

include/trace/events/btrfs.h

2162

TP_PROTO(struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2165

TP_ARGS(fs_info, sinfo),

include/trace/events/btrfs.h

2186

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2196

__entry->global_reserved = fs_info->global_block_rsv.reserved;

include/trace/events/btrfs.h

2197

__entry->trans_reserved = fs_info->trans_block_rsv.reserved;

include/trace/events/btrfs.h

2198

__entry->delayed_refs_reserved = fs_info->delayed_refs_rsv.reserved;

include/trace/events/btrfs.h

2199

__entry->delayed_reserved = fs_info->delayed_block_rsv.reserved;

include/trace/events/btrfs.h

2200

__entry->free_chunk_space = atomic64_read(&fs_info->free_chunk_space);

include/trace/events/btrfs.h

2201

__entry->delalloc_bytes = percpu_counter_sum_positive(&fs_info->delalloc_bytes);

include/trace/events/btrfs.h

2202

__entry->ordered_bytes = percpu_counter_sum_positive(&fs_info->ordered_bytes);

include/trace/events/btrfs.h

2224

TP_PROTO(struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2226

TP_ARGS(fs_info, sinfo)

include/trace/events/btrfs.h

2230

TP_PROTO(struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2232

TP_ARGS(fs_info, sinfo)

include/trace/events/btrfs.h

2236

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 bytes,

include/trace/events/btrfs.h

2239

TP_ARGS(fs_info, flags, bytes, start_ns, flush, error),

include/trace/events/btrfs.h

2249

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2279

TP_fast_assign_btrfs(eb->fs_info,

include/trace/events/btrfs.h

2320

TP_fast_assign_btrfs(eb->fs_info,

include/trace/events/btrfs.h

2345

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2348

TP_ARGS(fs_info, sinfo, old, diff),

include/trace/events/btrfs.h

2356

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2368

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2371

TP_ARGS(fs_info, sinfo, old, diff)

include/trace/events/btrfs.h

2376

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2379

TP_ARGS(fs_info, sinfo, old, diff)

include/trace/events/btrfs.h

2384

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

2387

TP_ARGS(fs_info, sinfo, old, diff)

include/trace/events/btrfs.h

2411

TP_fast_assign_btrfs(rbio->bioc->fs_info,

include/trace/events/btrfs.h

2459

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 logical, u64 length,

include/trace/events/btrfs.h

2462

TP_ARGS(fs_info, logical, length, num_stripes),

include/trace/events/btrfs.h

2470

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2483

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 end,

include/trace/events/btrfs.h

2486

TP_ARGS(fs_info, start, end, found_start, found_end),

include/trace/events/btrfs.h

2495

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2509

TP_PROTO(const struct btrfs_fs_info *fs_info, u64 logical, u64 length,

include/trace/events/btrfs.h

2512

TP_ARGS(fs_info, logical, length, physical, devid),

include/trace/events/btrfs.h

2521

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2535

TP_PROTO(const struct btrfs_fs_info *fs_info, long nr),

include/trace/events/btrfs.h

2537

TP_ARGS(fs_info, nr),

include/trace/events/btrfs.h

2543

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2552

TP_PROTO(const struct btrfs_fs_info *fs_info, long nr),

include/trace/events/btrfs.h

2554

TP_ARGS(fs_info, nr),

include/trace/events/btrfs.h

2563

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2565

atomic64_read(&fs_info->em_shrinker_nr_to_scan);

include/trace/events/btrfs.h

2567

__entry->last_root_id = fs_info->em_shrinker_last_root;

include/trace/events/btrfs.h

2568

__entry->last_ino = fs_info->em_shrinker_last_ino;

include/trace/events/btrfs.h

2578

TP_PROTO(const struct btrfs_fs_info *fs_info, long nr_dropped, long nr),

include/trace/events/btrfs.h

2580

TP_ARGS(fs_info, nr_dropped, nr),

include/trace/events/btrfs.h

2589

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

2592

__entry->last_root_id = fs_info->em_shrinker_last_root;

include/trace/events/btrfs.h

2593

__entry->last_ino = fs_info->em_shrinker_last_ino;

include/trace/events/btrfs.h

2615

TP_fast_assign_btrfs(inode->root->fs_info,

include/trace/events/btrfs.h

299

TP_fast_assign_btrfs(root->fs_info,

include/trace/events/btrfs.h

319

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

323

TP_ARGS(fs_info, existing, map, start, len),

include/trace/events/btrfs.h

334

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

378

TP_fast_assign_btrfs(bi->root->fs_info,

include/trace/events/btrfs.h

429

bi->root->fs_info,

include/trace/events/btrfs.h

520

TP_fast_assign_btrfs(inode->root->fs_info,

include/trace/events/btrfs.h

662

TP_fast_assign_btrfs(inode->root->fs_info,

include/trace/events/btrfs.h

744

TP_fast_assign_btrfs(inode->root->fs_info,

include/trace/events/btrfs.h

794

TP_PROTO(const struct btrfs_fs_info *fs_info, int wait),

include/trace/events/btrfs.h

796

TP_ARGS(fs_info, wait),

include/trace/events/btrfs.h

802

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

811

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

814

TP_ARGS(fs_info, block_group, create),

include/trace/events/btrfs.h

825

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

856

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

859

TP_ARGS(fs_info, ref),

include/trace/events/btrfs.h

872

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

897

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

900

TP_ARGS(fs_info, ref)

include/trace/events/btrfs.h

905

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

908

TP_ARGS(fs_info, ref)

include/trace/events/btrfs.h

913

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

916

TP_ARGS(fs_info, ref),

include/trace/events/btrfs.h

930

TP_fast_assign_btrfs(fs_info,

include/trace/events/btrfs.h

958

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

961

TP_ARGS(fs_info, ref)

include/trace/events/btrfs.h

966

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

969

TP_ARGS(fs_info, ref)

include/trace/events/btrfs.h

974

TP_PROTO(const struct btrfs_fs_info *fs_info,

include/trace/events/btrfs.h

978

TP_ARGS(fs_info, head_ref, action),

include/trace/events/btrfs.h

987

TP_fast_assign_btrfs(fs_info,

mm/shmem.c

4253

const struct xattr *xattr_array, void *fs_info)