Lines Matching refs:block_group
26 int btrfs_should_fragment_free_space(struct btrfs_block_group *block_group)
28 struct btrfs_fs_info *fs_info = block_group->fs_info;
31 block_group->flags & BTRFS_BLOCK_GROUP_METADATA) ||
33 block_group->flags & BTRFS_BLOCK_GROUP_DATA);
162 * A block_group shouldn't be on the discard_list anymore.
163 * Remove the block_group from the discard_list to prevent us
180 struct btrfs_block_group *block_group)
187 ASSERT(block_group->length != 0);
195 if (block_group->start < cache->start) {
197 } else if (block_group->start > cache->start) {
206 rb_link_node(&block_group->cache_node, parent, p);
207 rb_insert_color_cached(&block_group->cache_node,
486 static void fragment_free_space(struct btrfs_block_group *block_group)
488 struct btrfs_fs_info *fs_info = block_group->fs_info;
489 u64 start = block_group->start;
490 u64 len = block_group->length;
491 u64 chunk = block_group->flags & BTRFS_BLOCK_GROUP_METADATA ?
496 btrfs_remove_free_space(block_group, start, chunk);
511 * @block_group: The target block group.
519 int btrfs_add_new_free_space(struct btrfs_block_group *block_group, u64 start,
522 struct btrfs_fs_info *info = block_group->fs_info;
540 ret = btrfs_add_free_space_async_trimmed(block_group,
554 ret = btrfs_add_free_space_async_trimmed(block_group, start,
568 * @block_group the block group to sample from
581 struct btrfs_block_group *block_group,
585 struct btrfs_fs_info *fs_info = block_group->fs_info;
588 u64 search_end = block_group->start + block_group->length;
603 extent_root = btrfs_extent_root(fs_info, max_t(u64, block_group->start,
610 search_offset = index * div_u64(block_group->length, max_index);
611 search_key.objectid = block_group->start + search_offset;
618 found_key->objectid >= block_group->start &&
638 * @block_group: the block group we are caching
670 struct btrfs_block_group *block_group)
672 struct btrfs_fs_info *fs_info = block_group->fs_info;
675 u64 min_size = block_group->length;
679 if (!btrfs_block_group_should_use_size_class(block_group))
685 ret = sample_block_group_extent_item(caching_ctl, block_group, i, 5, &key);
694 spin_lock(&block_group->lock);
695 block_group->size_class = size_class;
696 spin_unlock(&block_group->lock);
704 struct btrfs_block_group *block_group = caching_ctl->block_group;
705 struct btrfs_fs_info *fs_info = block_group->fs_info;
720 last = max_t(u64, block_group->start, BTRFS_SUPER_INFO_OFFSET);
729 if (btrfs_should_fragment_free_space(block_group))
796 if (key.objectid < block_group->start) {
801 if (key.objectid >= block_group->start + block_group->length)
808 ret = btrfs_add_new_free_space(block_group, last,
830 ret = btrfs_add_new_free_space(block_group, last,
831 block_group->start + block_group->length,
846 struct btrfs_block_group *block_group;
852 block_group = caching_ctl->block_group;
853 fs_info = block_group->fs_info;
858 load_block_group_size_class(caching_ctl, block_group);
860 ret = load_free_space_cache(block_group);
870 spin_lock(&block_group->lock);
871 block_group->cached = BTRFS_CACHE_STARTED;
872 spin_unlock(&block_group->lock);
889 spin_lock(&block_group->lock);
890 block_group->caching_ctl = NULL;
891 block_group->cached = ret ? BTRFS_CACHE_ERROR : BTRFS_CACHE_FINISHED;
892 spin_unlock(&block_group->lock);
895 if (btrfs_should_fragment_free_space(block_group)) {
898 spin_lock(&block_group->space_info->lock);
899 spin_lock(&block_group->lock);
900 bytes_used = block_group->length - block_group->used;
901 block_group->space_info->bytes_used += bytes_used >> 1;
902 spin_unlock(&block_group->lock);
903 spin_unlock(&block_group->space_info->lock);
904 fragment_free_space(block_group);
909 btrfs_free_excluded_extents(block_group);
915 btrfs_put_block_group(block_group);
935 caching_ctl->block_group = cache;
1027 struct btrfs_block_group *block_group)
1035 key.objectid = block_group->start;
1037 key.offset = block_group->length;
1054 struct btrfs_block_group *block_group;
1065 block_group = btrfs_lookup_block_group(fs_info, map->start);
1066 if (!block_group)
1069 BUG_ON(!block_group->ro);
1071 trace_btrfs_remove_block_group(block_group);
1076 btrfs_free_excluded_extents(block_group);
1077 btrfs_free_ref_tree_range(fs_info, block_group->start,
1078 block_group->length);
1080 index = btrfs_bg_flags_to_raid_index(block_group->flags);
1081 factor = btrfs_bg_type_to_factor(block_group->flags);
1086 btrfs_return_cluster_to_free_space(block_group, cluster);
1095 btrfs_return_cluster_to_free_space(block_group, cluster);
1098 btrfs_clear_treelog_bg(block_group);
1099 btrfs_clear_data_reloc_bg(block_group);
1111 inode = lookup_free_space_inode(block_group, path);
1119 if (!list_empty(&block_group->io_list)) {
1120 list_del_init(&block_group->io_list);
1122 WARN_ON(!IS_ERR(inode) && inode != block_group->io_ctl.inode);
1125 btrfs_wait_cache_io(trans, block_group, path);
1126 btrfs_put_block_group(block_group);
1130 if (!list_empty(&block_group->dirty_list)) {
1131 list_del_init(&block_group->dirty_list);
1133 btrfs_put_block_group(block_group);
1138 ret = btrfs_remove_free_space_inode(trans, inode, block_group);
1143 rb_erase_cached(&block_group->cache_node,
1145 RB_CLEAR_NODE(&block_group->cache_node);
1148 btrfs_put_block_group(block_group);
1152 down_write(&block_group->space_info->groups_sem);
1157 list_del_init(&block_group->list);
1158 if (list_empty(&block_group->space_info->block_groups[index])) {
1159 kobj = block_group->space_info->block_group_kobjs[index];
1160 block_group->space_info->block_group_kobjs[index] = NULL;
1161 clear_avail_alloc_bits(fs_info, block_group->flags);
1163 up_write(&block_group->space_info->groups_sem);
1164 clear_incompat_bg_bits(fs_info, block_group->flags);
1170 if (block_group->cached == BTRFS_CACHE_STARTED)
1171 btrfs_wait_block_group_cache_done(block_group);
1174 caching_ctl = btrfs_get_caching_control(block_group);
1179 if (ctl->block_group == block_group) {
1197 WARN_ON(!list_empty(&block_group->dirty_list));
1198 WARN_ON(!list_empty(&block_group->io_list));
1201 btrfs_remove_free_space_cache(block_group);
1203 spin_lock(&block_group->space_info->lock);
1204 list_del_init(&block_group->ro_list);
1207 WARN_ON(block_group->space_info->total_bytes
1208 < block_group->length);
1209 WARN_ON(block_group->space_info->bytes_readonly
1210 < block_group->length - block_group->zone_unusable);
1211 WARN_ON(block_group->space_info->bytes_zone_unusable
1212 < block_group->zone_unusable);
1213 WARN_ON(block_group->space_info->disk_total
1214 < block_group->length * factor);
1216 block_group->space_info->total_bytes -= block_group->length;
1217 block_group->space_info->bytes_readonly -=
1218 (block_group->length - block_group->zone_unusable);
1219 block_group->space_info->bytes_zone_unusable -=
1220 block_group->zone_unusable;
1221 block_group->space_info->disk_total -= block_group->length * factor;
1223 spin_unlock(&block_group->space_info->lock);
1236 ret = remove_block_group_free_space(trans, block_group);
1240 ret = remove_block_group_item(trans, path, block_group);
1244 spin_lock(&block_group->lock);
1245 set_bit(BLOCK_GROUP_FLAG_REMOVED, &block_group->runtime_flags);
1252 * from the rbtree, they have already incremented block_group->frozen -
1273 remove_map = (atomic_read(&block_group->frozen) == 0);
1274 spin_unlock(&block_group->lock);
1281 btrfs_put_block_group(block_group);
1461 struct btrfs_block_group *block_group;
1485 block_group = list_first_entry(&fs_info->unused_bgs,
1488 list_del_init(&block_group->bg_list);
1490 space_info = block_group->space_info;
1493 btrfs_put_block_group(block_group);
1498 btrfs_discard_cancel_work(&fs_info->discard_ctl, block_group);
1509 !btrfs_is_free_space_trimmed(block_group)) {
1510 trace_btrfs_skip_unused_block_group(block_group);
1514 block_group);
1519 spin_lock(&block_group->lock);
1520 if (btrfs_is_block_group_used(block_group) || block_group->ro ||
1521 list_is_singular(&block_group->list)) {
1535 trace_btrfs_skip_unused_block_group(block_group);
1536 spin_unlock(&block_group->lock);
1562 if (space_info->total_bytes - block_group->length < used &&
1563 block_group->zone_unusable < block_group->length) {
1569 btrfs_get_block_group(block_group);
1570 list_add_tail(&block_group->bg_list, &retry_list);
1572 trace_btrfs_skip_unused_block_group(block_group);
1573 spin_unlock(&block_group->lock);
1579 spin_unlock(&block_group->lock);
1583 ret = inc_block_group_ro(block_group, 0);
1590 ret = btrfs_zone_finish(block_group);
1592 btrfs_dec_block_group_ro(block_group);
1603 block_group->start);
1605 btrfs_dec_block_group_ro(block_group);
1614 if (!clean_pinned_extents(trans, block_group)) {
1615 btrfs_dec_block_group_ro(block_group);
1620 * At this point, the block_group is read only and should fail
1622 * cause this block_group to be placed back on the discard
1623 * lists because now the block_group isn't fully discarded.
1627 if (!list_empty(&block_group->discard_list)) {
1629 btrfs_dec_block_group_ro(block_group);
1631 block_group);
1638 spin_lock(&block_group->lock);
1641 -block_group->pinned);
1642 space_info->bytes_readonly += block_group->pinned;
1643 block_group->pinned = 0;
1645 spin_unlock(&block_group->lock);
1667 btrfs_freeze_block_group(block_group);
1673 ret = btrfs_remove_chunk(trans, block_group->start);
1677 btrfs_unfreeze_block_group(block_group);
1693 list_move(&block_group->bg_list,
1696 btrfs_get_block_group(block_group);
1701 btrfs_put_block_group(block_group);
1715 btrfs_put_block_group(block_group);
2572 struct btrfs_block_group *block_group)
2581 spin_lock(&block_group->lock);
2582 btrfs_set_stack_block_group_used(&bgi, block_group->used);
2584 block_group->global_root_id);
2585 btrfs_set_stack_block_group_flags(&bgi, block_group->flags);
2586 old_commit_used = block_group->commit_used;
2587 block_group->commit_used = block_group->used;
2588 key.objectid = block_group->start;
2590 key.offset = block_group->length;
2591 spin_unlock(&block_group->lock);
2595 spin_lock(&block_group->lock);
2596 block_group->commit_used = old_commit_used;
2597 spin_unlock(&block_group->lock);
2697 struct btrfs_block_group *block_group;
2703 block_group = list_first_entry(&trans->new_bgs,
2709 index = btrfs_bg_flags_to_raid_index(block_group->flags);
2711 ret = insert_block_group_item(trans, block_group);
2715 &block_group->runtime_flags)) {
2717 ret = btrfs_chunk_alloc_add_chunk_item(trans, block_group);
2722 ret = insert_dev_extents(trans, block_group->start,
2723 block_group->length);
2726 add_block_group_free_space(trans, block_group);
2734 if (block_group->space_info->block_group_kobjs[index] == NULL)
2735 btrfs_sysfs_add_block_group_type(block_group);
2740 list_del_init(&block_group->bg_list);
2741 clear_bit(BLOCK_GROUP_FLAG_NEW, &block_group->runtime_flags);
2766 spin_lock(&block_group->lock);
2767 used = btrfs_is_block_group_used(block_group);
2768 spin_unlock(&block_group->lock);
2771 btrfs_mark_bg_unused(block_group);
3106 static int cache_save_setup(struct btrfs_block_group *block_group,
3110 struct btrfs_fs_info *fs_info = block_group->fs_info;
3126 if (block_group->length < (100 * SZ_1M)) {
3127 spin_lock(&block_group->lock);
3128 block_group->disk_cache_state = BTRFS_DC_WRITTEN;
3129 spin_unlock(&block_group->lock);
3136 inode = lookup_free_space_inode(block_group, path);
3147 if (block_group->ro)
3150 ret = create_free_space_inode(trans, block_group, path);
3180 if (block_group->cache_generation == trans->transid &&
3197 spin_lock(&block_group->lock);
3198 if (block_group->cached != BTRFS_CACHE_FINISHED ||
3207 spin_unlock(&block_group->lock);
3210 spin_unlock(&block_group->lock);
3227 cache_size = div_u64(block_group->length, SZ_256M);
3260 spin_lock(&block_group->lock);
3262 block_group->cache_generation = trans->transid;
3263 block_group->disk_cache_state = dcs;
3264 spin_unlock(&block_group->lock);
3701 * Update the block_group and space info counters.
3756 * Update the block_group and space info counters.
4308 struct btrfs_block_group *block_group;
4310 block_group = btrfs_lookup_first_block_group(info, 0);
4311 while (block_group) {
4312 btrfs_wait_block_group_cache_done(block_group);
4313 spin_lock(&block_group->lock);
4315 &block_group->runtime_flags)) {
4316 struct inode *inode = block_group->inode;
4318 block_group->inode = NULL;
4319 spin_unlock(&block_group->lock);
4321 ASSERT(block_group->io_ctl.inode == NULL);
4324 spin_unlock(&block_group->lock);
4326 block_group = btrfs_next_block_group(block_group);
4337 struct btrfs_block_group *block_group;
4364 block_group = list_first_entry(&info->unused_bgs,
4367 list_del_init(&block_group->bg_list);
4368 btrfs_put_block_group(block_group);
4372 block_group = list_first_entry(&info->reclaim_bgs,
4375 list_del_init(&block_group->bg_list);
4376 btrfs_put_block_group(block_group);
4382 block_group = list_first_entry(&info->zone_active_bgs,
4385 list_del_init(&block_group->active_bg_list);
4386 btrfs_put_block_group(block_group);
4392 block_group = rb_entry(n, struct btrfs_block_group,
4394 rb_erase_cached(&block_group->cache_node,
4396 RB_CLEAR_NODE(&block_group->cache_node);
4399 down_write(&block_group->space_info->groups_sem);
4400 list_del(&block_group->list);
4401 up_write(&block_group->space_info->groups_sem);
4407 if (block_group->cached == BTRFS_CACHE_NO ||
4408 block_group->cached == BTRFS_CACHE_ERROR)
4409 btrfs_free_excluded_extents(block_group);
4411 btrfs_remove_free_space_cache(block_group);
4412 ASSERT(block_group->cached != BTRFS_CACHE_STARTED);
4413 ASSERT(list_empty(&block_group->dirty_list));
4414 ASSERT(list_empty(&block_group->io_list));
4415 ASSERT(list_empty(&block_group->bg_list));
4416 ASSERT(refcount_read(&block_group->refs) == 1);
4417 ASSERT(block_group->swap_extents == 0);
4418 btrfs_put_block_group(block_group);
4464 void btrfs_unfreeze_block_group(struct btrfs_block_group *block_group)
4466 struct btrfs_fs_info *fs_info = block_group->fs_info;
4469 spin_lock(&block_group->lock);
4470 cleanup = (atomic_dec_and_test(&block_group->frozen) &&
4471 test_bit(BLOCK_GROUP_FLAG_REMOVED, &block_group->runtime_flags));
4472 spin_unlock(&block_group->lock);
4477 map = btrfs_find_chunk_map(fs_info, block_group->start, 1);
4491 btrfs_remove_free_space_cache(block_group);
4535 * Returns: 0 if the size class was valid for this block_group, -EAGAIN in the
4560 * and hit the same empty block_group. Make the loser try again.
4572 * one in the block_group so we set size_class.