linux/fs/btrfs/block-group.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2
   3#include "misc.h"
   4#include "ctree.h"
   5#include "block-group.h"
   6#include "space-info.h"
   7#include "disk-io.h"
   8#include "free-space-cache.h"
   9#include "free-space-tree.h"
  10#include "volumes.h"
  11#include "transaction.h"
  12#include "ref-verify.h"
  13#include "sysfs.h"
  14#include "tree-log.h"
  15#include "delalloc-space.h"
  16#include "discard.h"
  17#include "raid56.h"
  18#include "zoned.h"
  19
  20/*
  21 * Return target flags in extended format or 0 if restripe for this chunk_type
  22 * is not in progress
  23 *
  24 * Should be called with balance_lock held
  25 */
  26static u64 get_restripe_target(struct btrfs_fs_info *fs_info, u64 flags)
  27{
  28        struct btrfs_balance_control *bctl = fs_info->balance_ctl;
  29        u64 target = 0;
  30
  31        if (!bctl)
  32                return 0;
  33
  34        if (flags & BTRFS_BLOCK_GROUP_DATA &&
  35            bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) {
  36                target = BTRFS_BLOCK_GROUP_DATA | bctl->data.target;
  37        } else if (flags & BTRFS_BLOCK_GROUP_SYSTEM &&
  38                   bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
  39                target = BTRFS_BLOCK_GROUP_SYSTEM | bctl->sys.target;
  40        } else if (flags & BTRFS_BLOCK_GROUP_METADATA &&
  41                   bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) {
  42                target = BTRFS_BLOCK_GROUP_METADATA | bctl->meta.target;
  43        }
  44
  45        return target;
  46}
  47
  48/*
  49 * @flags: available profiles in extended format (see ctree.h)
  50 *
  51 * Return reduced profile in chunk format.  If profile changing is in progress
  52 * (either running or paused) picks the target profile (if it's already
  53 * available), otherwise falls back to plain reducing.
  54 */
  55static u64 btrfs_reduce_alloc_profile(struct btrfs_fs_info *fs_info, u64 flags)
  56{
  57        u64 num_devices = fs_info->fs_devices->rw_devices;
  58        u64 target;
  59        u64 raid_type;
  60        u64 allowed = 0;
  61
  62        /*
  63         * See if restripe for this chunk_type is in progress, if so try to
  64         * reduce to the target profile
  65         */
  66        spin_lock(&fs_info->balance_lock);
  67        target = get_restripe_target(fs_info, flags);
  68        if (target) {
  69                spin_unlock(&fs_info->balance_lock);
  70                return extended_to_chunk(target);
  71        }
  72        spin_unlock(&fs_info->balance_lock);
  73
  74        /* First, mask out the RAID levels which aren't possible */
  75        for (raid_type = 0; raid_type < BTRFS_NR_RAID_TYPES; raid_type++) {
  76                if (num_devices >= btrfs_raid_array[raid_type].devs_min)
  77                        allowed |= btrfs_raid_array[raid_type].bg_flag;
  78        }
  79        allowed &= flags;
  80
  81        if (allowed & BTRFS_BLOCK_GROUP_RAID6)
  82                allowed = BTRFS_BLOCK_GROUP_RAID6;
  83        else if (allowed & BTRFS_BLOCK_GROUP_RAID5)
  84                allowed = BTRFS_BLOCK_GROUP_RAID5;
  85        else if (allowed & BTRFS_BLOCK_GROUP_RAID10)
  86                allowed = BTRFS_BLOCK_GROUP_RAID10;
  87        else if (allowed & BTRFS_BLOCK_GROUP_RAID1)
  88                allowed = BTRFS_BLOCK_GROUP_RAID1;
  89        else if (allowed & BTRFS_BLOCK_GROUP_RAID0)
  90                allowed = BTRFS_BLOCK_GROUP_RAID0;
  91
  92        flags &= ~BTRFS_BLOCK_GROUP_PROFILE_MASK;
  93
  94        return extended_to_chunk(flags | allowed);
  95}
  96
  97u64 btrfs_get_alloc_profile(struct btrfs_fs_info *fs_info, u64 orig_flags)
  98{
  99        unsigned seq;
 100        u64 flags;
 101
 102        do {
 103                flags = orig_flags;
 104                seq = read_seqbegin(&fs_info->profiles_lock);
 105
 106                if (flags & BTRFS_BLOCK_GROUP_DATA)
 107                        flags |= fs_info->avail_data_alloc_bits;
 108                else if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
 109                        flags |= fs_info->avail_system_alloc_bits;
 110                else if (flags & BTRFS_BLOCK_GROUP_METADATA)
 111                        flags |= fs_info->avail_metadata_alloc_bits;
 112        } while (read_seqretry(&fs_info->profiles_lock, seq));
 113
 114        return btrfs_reduce_alloc_profile(fs_info, flags);
 115}
 116
 117void btrfs_get_block_group(struct btrfs_block_group *cache)
 118{
 119        refcount_inc(&cache->refs);
 120}
 121
 122void btrfs_put_block_group(struct btrfs_block_group *cache)
 123{
 124        if (refcount_dec_and_test(&cache->refs)) {
 125                WARN_ON(cache->pinned > 0);
 126                WARN_ON(cache->reserved > 0);
 127
 128                /*
 129                 * A block_group shouldn't be on the discard_list anymore.
 130                 * Remove the block_group from the discard_list to prevent us
 131                 * from causing a panic due to NULL pointer dereference.
 132                 */
 133                if (WARN_ON(!list_empty(&cache->discard_list)))
 134                        btrfs_discard_cancel_work(&cache->fs_info->discard_ctl,
 135                                                  cache);
 136
 137                /*
 138                 * If not empty, someone is still holding mutex of
 139                 * full_stripe_lock, which can only be released by caller.
 140                 * And it will definitely cause use-after-free when caller
 141                 * tries to release full stripe lock.
 142                 *
 143                 * No better way to resolve, but only to warn.
 144                 */
 145                WARN_ON(!RB_EMPTY_ROOT(&cache->full_stripe_locks_root.root));
 146                kfree(cache->free_space_ctl);
 147                kfree(cache);
 148        }
 149}
 150
 151/*
 152 * This adds the block group to the fs_info rb tree for the block group cache
 153 */
 154static int btrfs_add_block_group_cache(struct btrfs_fs_info *info,
 155                                       struct btrfs_block_group *block_group)
 156{
 157        struct rb_node **p;
 158        struct rb_node *parent = NULL;
 159        struct btrfs_block_group *cache;
 160
 161        ASSERT(block_group->length != 0);
 162
 163        spin_lock(&info->block_group_cache_lock);
 164        p = &info->block_group_cache_tree.rb_node;
 165
 166        while (*p) {
 167                parent = *p;
 168                cache = rb_entry(parent, struct btrfs_block_group, cache_node);
 169                if (block_group->start < cache->start) {
 170                        p = &(*p)->rb_left;
 171                } else if (block_group->start > cache->start) {
 172                        p = &(*p)->rb_right;
 173                } else {
 174                        spin_unlock(&info->block_group_cache_lock);
 175                        return -EEXIST;
 176                }
 177        }
 178
 179        rb_link_node(&block_group->cache_node, parent, p);
 180        rb_insert_color(&block_group->cache_node,
 181                        &info->block_group_cache_tree);
 182
 183        if (info->first_logical_byte > block_group->start)
 184                info->first_logical_byte = block_group->start;
 185
 186        spin_unlock(&info->block_group_cache_lock);
 187
 188        return 0;
 189}
 190
 191/*
 192 * This will return the block group at or after bytenr if contains is 0, else
 193 * it will return the block group that contains the bytenr
 194 */
 195static struct btrfs_block_group *block_group_cache_tree_search(
 196                struct btrfs_fs_info *info, u64 bytenr, int contains)
 197{
 198        struct btrfs_block_group *cache, *ret = NULL;
 199        struct rb_node *n;
 200        u64 end, start;
 201
 202        spin_lock(&info->block_group_cache_lock);
 203        n = info->block_group_cache_tree.rb_node;
 204
 205        while (n) {
 206                cache = rb_entry(n, struct btrfs_block_group, cache_node);
 207                end = cache->start + cache->length - 1;
 208                start = cache->start;
 209
 210                if (bytenr < start) {
 211                        if (!contains && (!ret || start < ret->start))
 212                                ret = cache;
 213                        n = n->rb_left;
 214                } else if (bytenr > start) {
 215                        if (contains && bytenr <= end) {
 216                                ret = cache;
 217                                break;
 218                        }
 219                        n = n->rb_right;
 220                } else {
 221                        ret = cache;
 222                        break;
 223                }
 224        }
 225        if (ret) {
 226                btrfs_get_block_group(ret);
 227                if (bytenr == 0 && info->first_logical_byte > ret->start)
 228                        info->first_logical_byte = ret->start;
 229        }
 230        spin_unlock(&info->block_group_cache_lock);
 231
 232        return ret;
 233}
 234
 235/*
 236 * Return the block group that starts at or after bytenr
 237 */
 238struct btrfs_block_group *btrfs_lookup_first_block_group(
 239                struct btrfs_fs_info *info, u64 bytenr)
 240{
 241        return block_group_cache_tree_search(info, bytenr, 0);
 242}
 243
 244/*
 245 * Return the block group that contains the given bytenr
 246 */
 247struct btrfs_block_group *btrfs_lookup_block_group(
 248                struct btrfs_fs_info *info, u64 bytenr)
 249{
 250        return block_group_cache_tree_search(info, bytenr, 1);
 251}
 252
 253struct btrfs_block_group *btrfs_next_block_group(
 254                struct btrfs_block_group *cache)
 255{
 256        struct btrfs_fs_info *fs_info = cache->fs_info;
 257        struct rb_node *node;
 258
 259        spin_lock(&fs_info->block_group_cache_lock);
 260
 261        /* If our block group was removed, we need a full search. */
 262        if (RB_EMPTY_NODE(&cache->cache_node)) {
 263                const u64 next_bytenr = cache->start + cache->length;
 264
 265                spin_unlock(&fs_info->block_group_cache_lock);
 266                btrfs_put_block_group(cache);
 267                cache = btrfs_lookup_first_block_group(fs_info, next_bytenr); return cache;
 268        }
 269        node = rb_next(&cache->cache_node);
 270        btrfs_put_block_group(cache);
 271        if (node) {
 272                cache = rb_entry(node, struct btrfs_block_group, cache_node);
 273                btrfs_get_block_group(cache);
 274        } else
 275                cache = NULL;
 276        spin_unlock(&fs_info->block_group_cache_lock);
 277        return cache;
 278}
 279
 280bool btrfs_inc_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr)
 281{
 282        struct btrfs_block_group *bg;
 283        bool ret = true;
 284
 285        bg = btrfs_lookup_block_group(fs_info, bytenr);
 286        if (!bg)
 287                return false;
 288
 289        spin_lock(&bg->lock);
 290        if (bg->ro)
 291                ret = false;
 292        else
 293                atomic_inc(&bg->nocow_writers);
 294        spin_unlock(&bg->lock);
 295
 296        /* No put on block group, done by btrfs_dec_nocow_writers */
 297        if (!ret)
 298                btrfs_put_block_group(bg);
 299
 300        return ret;
 301}
 302
 303void btrfs_dec_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr)
 304{
 305        struct btrfs_block_group *bg;
 306
 307        bg = btrfs_lookup_block_group(fs_info, bytenr);
 308        ASSERT(bg);
 309        if (atomic_dec_and_test(&bg->nocow_writers))
 310                wake_up_var(&bg->nocow_writers);
 311        /*
 312         * Once for our lookup and once for the lookup done by a previous call
 313         * to btrfs_inc_nocow_writers()
 314         */
 315        btrfs_put_block_group(bg);
 316        btrfs_put_block_group(bg);
 317}
 318
 319void btrfs_wait_nocow_writers(struct btrfs_block_group *bg)
 320{
 321        wait_var_event(&bg->nocow_writers, !atomic_read(&bg->nocow_writers));
 322}
 323
 324void btrfs_dec_block_group_reservations(struct btrfs_fs_info *fs_info,
 325                                        const u64 start)
 326{
 327        struct btrfs_block_group *bg;
 328
 329        bg = btrfs_lookup_block_group(fs_info, start);
 330        ASSERT(bg);
 331        if (atomic_dec_and_test(&bg->reservations))
 332                wake_up_var(&bg->reservations);
 333        btrfs_put_block_group(bg);
 334}
 335
 336void btrfs_wait_block_group_reservations(struct btrfs_block_group *bg)
 337{
 338        struct btrfs_space_info *space_info = bg->space_info;
 339
 340        ASSERT(bg->ro);
 341
 342        if (!(bg->flags & BTRFS_BLOCK_GROUP_DATA))
 343                return;
 344
 345        /*
 346         * Our block group is read only but before we set it to read only,
 347         * some task might have had allocated an extent from it already, but it
 348         * has not yet created a respective ordered extent (and added it to a
 349         * root's list of ordered extents).
 350         * Therefore wait for any task currently allocating extents, since the
 351         * block group's reservations counter is incremented while a read lock
 352         * on the groups' semaphore is held and decremented after releasing
 353         * the read access on that semaphore and creating the ordered extent.
 354         */
 355        down_write(&space_info->groups_sem);
 356        up_write(&space_info->groups_sem);
 357
 358        wait_var_event(&bg->reservations, !atomic_read(&bg->reservations));
 359}
 360
 361struct btrfs_caching_control *btrfs_get_caching_control(
 362                struct btrfs_block_group *cache)
 363{
 364        struct btrfs_caching_control *ctl;
 365
 366        spin_lock(&cache->lock);
 367        if (!cache->caching_ctl) {
 368                spin_unlock(&cache->lock);
 369                return NULL;
 370        }
 371
 372        ctl = cache->caching_ctl;
 373        refcount_inc(&ctl->count);
 374        spin_unlock(&cache->lock);
 375        return ctl;
 376}
 377
 378void btrfs_put_caching_control(struct btrfs_caching_control *ctl)
 379{
 380        if (refcount_dec_and_test(&ctl->count))
 381                kfree(ctl);
 382}
 383
 384/*
 385 * When we wait for progress in the block group caching, its because our
 386 * allocation attempt failed at least once.  So, we must sleep and let some
 387 * progress happen before we try again.
 388 *
 389 * This function will sleep at least once waiting for new free space to show
 390 * up, and then it will check the block group free space numbers for our min
 391 * num_bytes.  Another option is to have it go ahead and look in the rbtree for
 392 * a free extent of a given size, but this is a good start.
 393 *
 394 * Callers of this must check if cache->cached == BTRFS_CACHE_ERROR before using
 395 * any of the information in this block group.
 396 */
 397void btrfs_wait_block_group_cache_progress(struct btrfs_block_group *cache,
 398                                           u64 num_bytes)
 399{
 400        struct btrfs_caching_control *caching_ctl;
 401
 402        caching_ctl = btrfs_get_caching_control(cache);
 403        if (!caching_ctl)
 404                return;
 405
 406        wait_event(caching_ctl->wait, btrfs_block_group_done(cache) ||
 407                   (cache->free_space_ctl->free_space >= num_bytes));
 408
 409        btrfs_put_caching_control(caching_ctl);
 410}
 411
 412int btrfs_wait_block_group_cache_done(struct btrfs_block_group *cache)
 413{
 414        struct btrfs_caching_control *caching_ctl;
 415        int ret = 0;
 416
 417        caching_ctl = btrfs_get_caching_control(cache);
 418        if (!caching_ctl)
 419                return (cache->cached == BTRFS_CACHE_ERROR) ? -EIO : 0;
 420
 421        wait_event(caching_ctl->wait, btrfs_block_group_done(cache));
 422        if (cache->cached == BTRFS_CACHE_ERROR)
 423                ret = -EIO;
 424        btrfs_put_caching_control(caching_ctl);
 425        return ret;
 426}
 427
 428static bool space_cache_v1_done(struct btrfs_block_group *cache)
 429{
 430        bool ret;
 431
 432        spin_lock(&cache->lock);
 433        ret = cache->cached != BTRFS_CACHE_FAST;
 434        spin_unlock(&cache->lock);
 435
 436        return ret;
 437}
 438
 439void btrfs_wait_space_cache_v1_finished(struct btrfs_block_group *cache,
 440                                struct btrfs_caching_control *caching_ctl)
 441{
 442        wait_event(caching_ctl->wait, space_cache_v1_done(cache));
 443}
 444
 445#ifdef CONFIG_BTRFS_DEBUG
 446static void fragment_free_space(struct btrfs_block_group *block_group)
 447{
 448        struct btrfs_fs_info *fs_info = block_group->fs_info;
 449        u64 start = block_group->start;
 450        u64 len = block_group->length;
 451        u64 chunk = block_group->flags & BTRFS_BLOCK_GROUP_METADATA ?
 452                fs_info->nodesize : fs_info->sectorsize;
 453        u64 step = chunk << 1;
 454
 455        while (len > chunk) {
 456                btrfs_remove_free_space(block_group, start, chunk);
 457                start += step;
 458                if (len < step)
 459                        len = 0;
 460                else
 461                        len -= step;
 462        }
 463}
 464#endif
 465
 466/*
 467 * This is only called by btrfs_cache_block_group, since we could have freed
 468 * extents we need to check the pinned_extents for any extents that can't be
 469 * used yet since their free space will be released as soon as the transaction
 470 * commits.
 471 */
 472u64 add_new_free_space(struct btrfs_block_group *block_group, u64 start, u64 end)
 473{
 474        struct btrfs_fs_info *info = block_group->fs_info;
 475        u64 extent_start, extent_end, size, total_added = 0;
 476        int ret;
 477
 478        while (start < end) {
 479                ret = find_first_extent_bit(&info->excluded_extents, start,
 480                                            &extent_start, &extent_end,
 481                                            EXTENT_DIRTY | EXTENT_UPTODATE,
 482                                            NULL);
 483                if (ret)
 484                        break;
 485
 486                if (extent_start <= start) {
 487                        start = extent_end + 1;
 488                } else if (extent_start > start && extent_start < end) {
 489                        size = extent_start - start;
 490                        total_added += size;
 491                        ret = btrfs_add_free_space_async_trimmed(block_group,
 492                                                                 start, size);
 493                        BUG_ON(ret); /* -ENOMEM or logic error */
 494                        start = extent_end + 1;
 495                } else {
 496                        break;
 497                }
 498        }
 499
 500        if (start < end) {
 501                size = end - start;
 502                total_added += size;
 503                ret = btrfs_add_free_space_async_trimmed(block_group, start,
 504                                                         size);
 505                BUG_ON(ret); /* -ENOMEM or logic error */
 506        }
 507
 508        return total_added;
 509}
 510
 511static int load_extent_tree_free(struct btrfs_caching_control *caching_ctl)
 512{
 513        struct btrfs_block_group *block_group = caching_ctl->block_group;
 514        struct btrfs_fs_info *fs_info = block_group->fs_info;
 515        struct btrfs_root *extent_root = fs_info->extent_root;
 516        struct btrfs_path *path;
 517        struct extent_buffer *leaf;
 518        struct btrfs_key key;
 519        u64 total_found = 0;
 520        u64 last = 0;
 521        u32 nritems;
 522        int ret;
 523        bool wakeup = true;
 524
 525        path = btrfs_alloc_path();
 526        if (!path)
 527                return -ENOMEM;
 528
 529        last = max_t(u64, block_group->start, BTRFS_SUPER_INFO_OFFSET);
 530
 531#ifdef CONFIG_BTRFS_DEBUG
 532        /*
 533         * If we're fragmenting we don't want to make anybody think we can
 534         * allocate from this block group until we've had a chance to fragment
 535         * the free space.
 536         */
 537        if (btrfs_should_fragment_free_space(block_group))
 538                wakeup = false;
 539#endif
 540        /*
 541         * We don't want to deadlock with somebody trying to allocate a new
 542         * extent for the extent root while also trying to search the extent
 543         * root to add free space.  So we skip locking and search the commit
 544         * root, since its read-only
 545         */
 546        path->skip_locking = 1;
 547        path->search_commit_root = 1;
 548        path->reada = READA_FORWARD;
 549
 550        key.objectid = last;
 551        key.offset = 0;
 552        key.type = BTRFS_EXTENT_ITEM_KEY;
 553
 554next:
 555        ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
 556        if (ret < 0)
 557                goto out;
 558
 559        leaf = path->nodes[0];
 560        nritems = btrfs_header_nritems(leaf);
 561
 562        while (1) {
 563                if (btrfs_fs_closing(fs_info) > 1) {
 564                        last = (u64)-1;
 565                        break;
 566                }
 567
 568                if (path->slots[0] < nritems) {
 569                        btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 570                } else {
 571                        ret = btrfs_find_next_key(extent_root, path, &key, 0, 0);
 572                        if (ret)
 573                                break;
 574
 575                        if (need_resched() ||
 576                            rwsem_is_contended(&fs_info->commit_root_sem)) {
 577                                if (wakeup)
 578                                        caching_ctl->progress = last;
 579                                btrfs_release_path(path);
 580                                up_read(&fs_info->commit_root_sem);
 581                                mutex_unlock(&caching_ctl->mutex);
 582                                cond_resched();
 583                                mutex_lock(&caching_ctl->mutex);
 584                                down_read(&fs_info->commit_root_sem);
 585                                goto next;
 586                        }
 587
 588                        ret = btrfs_next_leaf(extent_root, path);
 589                        if (ret < 0)
 590                                goto out;
 591                        if (ret)
 592                                break;
 593                        leaf = path->nodes[0];
 594                        nritems = btrfs_header_nritems(leaf);
 595                        continue;
 596                }
 597
 598                if (key.objectid < last) {
 599                        key.objectid = last;
 600                        key.offset = 0;
 601                        key.type = BTRFS_EXTENT_ITEM_KEY;
 602
 603                        if (wakeup)
 604                                caching_ctl->progress = last;
 605                        btrfs_release_path(path);
 606                        goto next;
 607                }
 608
 609                if (key.objectid < block_group->start) {
 610                        path->slots[0]++;
 611                        continue;
 612                }
 613
 614                if (key.objectid >= block_group->start + block_group->length)
 615                        break;
 616
 617                if (key.type == BTRFS_EXTENT_ITEM_KEY ||
 618                    key.type == BTRFS_METADATA_ITEM_KEY) {
 619                        total_found += add_new_free_space(block_group, last,
 620                                                          key.objectid);
 621                        if (key.type == BTRFS_METADATA_ITEM_KEY)
 622                                last = key.objectid +
 623                                        fs_info->nodesize;
 624                        else
 625                                last = key.objectid + key.offset;
 626
 627                        if (total_found > CACHING_CTL_WAKE_UP) {
 628                                total_found = 0;
 629                                if (wakeup)
 630                                        wake_up(&caching_ctl->wait);
 631                        }
 632                }
 633                path->slots[0]++;
 634        }
 635        ret = 0;
 636
 637        total_found += add_new_free_space(block_group, last,
 638                                block_group->start + block_group->length);
 639        caching_ctl->progress = (u64)-1;
 640
 641out:
 642        btrfs_free_path(path);
 643        return ret;
 644}
 645
 646static noinline void caching_thread(struct btrfs_work *work)
 647{
 648        struct btrfs_block_group *block_group;
 649        struct btrfs_fs_info *fs_info;
 650        struct btrfs_caching_control *caching_ctl;
 651        int ret;
 652
 653        caching_ctl = container_of(work, struct btrfs_caching_control, work);
 654        block_group = caching_ctl->block_group;
 655        fs_info = block_group->fs_info;
 656
 657        mutex_lock(&caching_ctl->mutex);
 658        down_read(&fs_info->commit_root_sem);
 659
 660        if (btrfs_test_opt(fs_info, SPACE_CACHE)) {
 661                ret = load_free_space_cache(block_group);
 662                if (ret == 1) {
 663                        ret = 0;
 664                        goto done;
 665                }
 666
 667                /*
 668                 * We failed to load the space cache, set ourselves to
 669                 * CACHE_STARTED and carry on.
 670                 */
 671                spin_lock(&block_group->lock);
 672                block_group->cached = BTRFS_CACHE_STARTED;
 673                spin_unlock(&block_group->lock);
 674                wake_up(&caching_ctl->wait);
 675        }
 676
 677        /*
 678         * If we are in the transaction that populated the free space tree we
 679         * can't actually cache from the free space tree as our commit root and
 680         * real root are the same, so we could change the contents of the blocks
 681         * while caching.  Instead do the slow caching in this case, and after
 682         * the transaction has committed we will be safe.
 683         */
 684        if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
 685            !(test_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags)))
 686                ret = load_free_space_tree(caching_ctl);
 687        else
 688                ret = load_extent_tree_free(caching_ctl);
 689done:
 690        spin_lock(&block_group->lock);
 691        block_group->caching_ctl = NULL;
 692        block_group->cached = ret ? BTRFS_CACHE_ERROR : BTRFS_CACHE_FINISHED;
 693        spin_unlock(&block_group->lock);
 694
 695#ifdef CONFIG_BTRFS_DEBUG
 696        if (btrfs_should_fragment_free_space(block_group)) {
 697                u64 bytes_used;
 698
 699                spin_lock(&block_group->space_info->lock);
 700                spin_lock(&block_group->lock);
 701                bytes_used = block_group->length - block_group->used;
 702                block_group->space_info->bytes_used += bytes_used >> 1;
 703                spin_unlock(&block_group->lock);
 704                spin_unlock(&block_group->space_info->lock);
 705                fragment_free_space(block_group);
 706        }
 707#endif
 708
 709        caching_ctl->progress = (u64)-1;
 710
 711        up_read(&fs_info->commit_root_sem);
 712        btrfs_free_excluded_extents(block_group);
 713        mutex_unlock(&caching_ctl->mutex);
 714
 715        wake_up(&caching_ctl->wait);
 716
 717        btrfs_put_caching_control(caching_ctl);
 718        btrfs_put_block_group(block_group);
 719}
 720
 721int btrfs_cache_block_group(struct btrfs_block_group *cache, int load_cache_only)
 722{
 723        DEFINE_WAIT(wait);
 724        struct btrfs_fs_info *fs_info = cache->fs_info;
 725        struct btrfs_caching_control *caching_ctl = NULL;
 726        int ret = 0;
 727
 728        /* Allocator for zoned filesystems does not use the cache at all */
 729        if (btrfs_is_zoned(fs_info))
 730                return 0;
 731
 732        caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_NOFS);
 733        if (!caching_ctl)
 734                return -ENOMEM;
 735
 736        INIT_LIST_HEAD(&caching_ctl->list);
 737        mutex_init(&caching_ctl->mutex);
 738        init_waitqueue_head(&caching_ctl->wait);
 739        caching_ctl->block_group = cache;
 740        caching_ctl->progress = cache->start;
 741        refcount_set(&caching_ctl->count, 2);
 742        btrfs_init_work(&caching_ctl->work, caching_thread, NULL, NULL);
 743
 744        spin_lock(&cache->lock);
 745        if (cache->cached != BTRFS_CACHE_NO) {
 746                kfree(caching_ctl);
 747
 748                caching_ctl = cache->caching_ctl;
 749                if (caching_ctl)
 750                        refcount_inc(&caching_ctl->count);
 751                spin_unlock(&cache->lock);
 752                goto out;
 753        }
 754        WARN_ON(cache->caching_ctl);
 755        cache->caching_ctl = caching_ctl;
 756        if (btrfs_test_opt(fs_info, SPACE_CACHE))
 757                cache->cached = BTRFS_CACHE_FAST;
 758        else
 759                cache->cached = BTRFS_CACHE_STARTED;
 760        cache->has_caching_ctl = 1;
 761        spin_unlock(&cache->lock);
 762
 763        spin_lock(&fs_info->block_group_cache_lock);
 764        refcount_inc(&caching_ctl->count);
 765        list_add_tail(&caching_ctl->list, &fs_info->caching_block_groups);
 766        spin_unlock(&fs_info->block_group_cache_lock);
 767
 768        btrfs_get_block_group(cache);
 769
 770        btrfs_queue_work(fs_info->caching_workers, &caching_ctl->work);
 771out:
 772        if (load_cache_only && caching_ctl)
 773                btrfs_wait_space_cache_v1_finished(cache, caching_ctl);
 774        if (caching_ctl)
 775                btrfs_put_caching_control(caching_ctl);
 776
 777        return ret;
 778}
 779
 780static void clear_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)
 781{
 782        u64 extra_flags = chunk_to_extended(flags) &
 783                                BTRFS_EXTENDED_PROFILE_MASK;
 784
 785        write_seqlock(&fs_info->profiles_lock);
 786        if (flags & BTRFS_BLOCK_GROUP_DATA)
 787                fs_info->avail_data_alloc_bits &= ~extra_flags;
 788        if (flags & BTRFS_BLOCK_GROUP_METADATA)
 789                fs_info->avail_metadata_alloc_bits &= ~extra_flags;
 790        if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
 791                fs_info->avail_system_alloc_bits &= ~extra_flags;
 792        write_sequnlock(&fs_info->profiles_lock);
 793}
 794
 795/*
 796 * Clear incompat bits for the following feature(s):
 797 *
 798 * - RAID56 - in case there's neither RAID5 nor RAID6 profile block group
 799 *            in the whole filesystem
 800 *
 801 * - RAID1C34 - same as above for RAID1C3 and RAID1C4 block groups
 802 */
 803static void clear_incompat_bg_bits(struct btrfs_fs_info *fs_info, u64 flags)
 804{
 805        bool found_raid56 = false;
 806        bool found_raid1c34 = false;
 807
 808        if ((flags & BTRFS_BLOCK_GROUP_RAID56_MASK) ||
 809            (flags & BTRFS_BLOCK_GROUP_RAID1C3) ||
 810            (flags & BTRFS_BLOCK_GROUP_RAID1C4)) {
 811                struct list_head *head = &fs_info->space_info;
 812                struct btrfs_space_info *sinfo;
 813
 814                list_for_each_entry_rcu(sinfo, head, list) {
 815                        down_read(&sinfo->groups_sem);
 816                        if (!list_empty(&sinfo->block_groups[BTRFS_RAID_RAID5]))
 817                                found_raid56 = true;
 818                        if (!list_empty(&sinfo->block_groups[BTRFS_RAID_RAID6]))
 819                                found_raid56 = true;
 820                        if (!list_empty(&sinfo->block_groups[BTRFS_RAID_RAID1C3]))
 821                                found_raid1c34 = true;
 822                        if (!list_empty(&sinfo->block_groups[BTRFS_RAID_RAID1C4]))
 823                                found_raid1c34 = true;
 824                        up_read(&sinfo->groups_sem);
 825                }
 826                if (!found_raid56)
 827                        btrfs_clear_fs_incompat(fs_info, RAID56);
 828                if (!found_raid1c34)
 829                        btrfs_clear_fs_incompat(fs_info, RAID1C34);
 830        }
 831}
 832
 833static int remove_block_group_item(struct btrfs_trans_handle *trans,
 834                                   struct btrfs_path *path,
 835                                   struct btrfs_block_group *block_group)
 836{
 837        struct btrfs_fs_info *fs_info = trans->fs_info;
 838        struct btrfs_root *root;
 839        struct btrfs_key key;
 840        int ret;
 841
 842        root = fs_info->extent_root;
 843        key.objectid = block_group->start;
 844        key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
 845        key.offset = block_group->length;
 846
 847        ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 848        if (ret > 0)
 849                ret = -ENOENT;
 850        if (ret < 0)
 851                return ret;
 852
 853        ret = btrfs_del_item(trans, root, path);
 854        return ret;
 855}
 856
 857int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
 858                             u64 group_start, struct extent_map *em)
 859{
 860        struct btrfs_fs_info *fs_info = trans->fs_info;
 861        struct btrfs_path *path;
 862        struct btrfs_block_group *block_group;
 863        struct btrfs_free_cluster *cluster;
 864        struct inode *inode;
 865        struct kobject *kobj = NULL;
 866        int ret;
 867        int index;
 868        int factor;
 869        struct btrfs_caching_control *caching_ctl = NULL;
 870        bool remove_em;
 871        bool remove_rsv = false;
 872
 873        block_group = btrfs_lookup_block_group(fs_info, group_start);
 874        BUG_ON(!block_group);
 875        BUG_ON(!block_group->ro);
 876
 877        trace_btrfs_remove_block_group(block_group);
 878        /*
 879         * Free the reserved super bytes from this block group before
 880         * remove it.
 881         */
 882        btrfs_free_excluded_extents(block_group);
 883        btrfs_free_ref_tree_range(fs_info, block_group->start,
 884                                  block_group->length);
 885
 886        index = btrfs_bg_flags_to_raid_index(block_group->flags);
 887        factor = btrfs_bg_type_to_factor(block_group->flags);
 888
 889        /* make sure this block group isn't part of an allocation cluster */
 890        cluster = &fs_info->data_alloc_cluster;
 891        spin_lock(&cluster->refill_lock);
 892        btrfs_return_cluster_to_free_space(block_group, cluster);
 893        spin_unlock(&cluster->refill_lock);
 894
 895        /*
 896         * make sure this block group isn't part of a metadata
 897         * allocation cluster
 898         */
 899        cluster = &fs_info->meta_alloc_cluster;
 900        spin_lock(&cluster->refill_lock);
 901        btrfs_return_cluster_to_free_space(block_group, cluster);
 902        spin_unlock(&cluster->refill_lock);
 903
 904        btrfs_clear_treelog_bg(block_group);
 905
 906        path = btrfs_alloc_path();
 907        if (!path) {
 908                ret = -ENOMEM;
 909                goto out;
 910        }
 911
 912        /*
 913         * get the inode first so any iput calls done for the io_list
 914         * aren't the final iput (no unlinks allowed now)
 915         */
 916        inode = lookup_free_space_inode(block_group, path);
 917
 918        mutex_lock(&trans->transaction->cache_write_mutex);
 919        /*
 920         * Make sure our free space cache IO is done before removing the
 921         * free space inode
 922         */
 923        spin_lock(&trans->transaction->dirty_bgs_lock);
 924        if (!list_empty(&block_group->io_list)) {
 925                list_del_init(&block_group->io_list);
 926
 927                WARN_ON(!IS_ERR(inode) && inode != block_group->io_ctl.inode);
 928
 929                spin_unlock(&trans->transaction->dirty_bgs_lock);
 930                btrfs_wait_cache_io(trans, block_group, path);
 931                btrfs_put_block_group(block_group);
 932                spin_lock(&trans->transaction->dirty_bgs_lock);
 933        }
 934
 935        if (!list_empty(&block_group->dirty_list)) {
 936                list_del_init(&block_group->dirty_list);
 937                remove_rsv = true;
 938                btrfs_put_block_group(block_group);
 939        }
 940        spin_unlock(&trans->transaction->dirty_bgs_lock);
 941        mutex_unlock(&trans->transaction->cache_write_mutex);
 942
 943        ret = btrfs_remove_free_space_inode(trans, inode, block_group);
 944        if (ret)
 945                goto out;
 946
 947        spin_lock(&fs_info->block_group_cache_lock);
 948        rb_erase(&block_group->cache_node,
 949                 &fs_info->block_group_cache_tree);
 950        RB_CLEAR_NODE(&block_group->cache_node);
 951
 952        /* Once for the block groups rbtree */
 953        btrfs_put_block_group(block_group);
 954
 955        if (fs_info->first_logical_byte == block_group->start)
 956                fs_info->first_logical_byte = (u64)-1;
 957        spin_unlock(&fs_info->block_group_cache_lock);
 958
 959        down_write(&block_group->space_info->groups_sem);
 960        /*
 961         * we must use list_del_init so people can check to see if they
 962         * are still on the list after taking the semaphore
 963         */
 964        list_del_init(&block_group->list);
 965        if (list_empty(&block_group->space_info->block_groups[index])) {
 966                kobj = block_group->space_info->block_group_kobjs[index];
 967                block_group->space_info->block_group_kobjs[index] = NULL;
 968                clear_avail_alloc_bits(fs_info, block_group->flags);
 969        }
 970        up_write(&block_group->space_info->groups_sem);
 971        clear_incompat_bg_bits(fs_info, block_group->flags);
 972        if (kobj) {
 973                kobject_del(kobj);
 974                kobject_put(kobj);
 975        }
 976
 977        if (block_group->has_caching_ctl)
 978                caching_ctl = btrfs_get_caching_control(block_group);
 979        if (block_group->cached == BTRFS_CACHE_STARTED)
 980                btrfs_wait_block_group_cache_done(block_group);
 981        if (block_group->has_caching_ctl) {
 982                spin_lock(&fs_info->block_group_cache_lock);
 983                if (!caching_ctl) {
 984                        struct btrfs_caching_control *ctl;
 985
 986                        list_for_each_entry(ctl,
 987                                    &fs_info->caching_block_groups, list)
 988                                if (ctl->block_group == block_group) {
 989                                        caching_ctl = ctl;
 990                                        refcount_inc(&caching_ctl->count);
 991                                        break;
 992                                }
 993                }
 994                if (caching_ctl)
 995                        list_del_init(&caching_ctl->list);
 996                spin_unlock(&fs_info->block_group_cache_lock);
 997                if (caching_ctl) {
 998                        /* Once for the caching bgs list and once for us. */
 999                        btrfs_put_caching_control(caching_ctl);
1000                        btrfs_put_caching_control(caching_ctl);
1001                }
1002        }
1003
1004        spin_lock(&trans->transaction->dirty_bgs_lock);
1005        WARN_ON(!list_empty(&block_group->dirty_list));
1006        WARN_ON(!list_empty(&block_group->io_list));
1007        spin_unlock(&trans->transaction->dirty_bgs_lock);
1008
1009        btrfs_remove_free_space_cache(block_group);
1010
1011        spin_lock(&block_group->space_info->lock);
1012        list_del_init(&block_group->ro_list);
1013
1014        if (btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {
1015                WARN_ON(block_group->space_info->total_bytes
1016                        < block_group->length);
1017                WARN_ON(block_group->space_info->bytes_readonly
1018                        < block_group->length - block_group->zone_unusable);
1019                WARN_ON(block_group->space_info->bytes_zone_unusable
1020                        < block_group->zone_unusable);
1021                WARN_ON(block_group->space_info->disk_total
1022                        < block_group->length * factor);
1023        }
1024        block_group->space_info->total_bytes -= block_group->length;
1025        block_group->space_info->bytes_readonly -=
1026                (block_group->length - block_group->zone_unusable);
1027        block_group->space_info->bytes_zone_unusable -=
1028                block_group->zone_unusable;
1029        block_group->space_info->disk_total -= block_group->length * factor;
1030
1031        spin_unlock(&block_group->space_info->lock);
1032
1033        /*
1034         * Remove the free space for the block group from the free space tree
1035         * and the block group's item from the extent tree before marking the
1036         * block group as removed. This is to prevent races with tasks that
1037         * freeze and unfreeze a block group, this task and another task
1038         * allocating a new block group - the unfreeze task ends up removing
1039         * the block group's extent map before the task calling this function
1040         * deletes the block group item from the extent tree, allowing for
1041         * another task to attempt to create another block group with the same
1042         * item key (and failing with -EEXIST and a transaction abort).
1043         */
1044        ret = remove_block_group_free_space(trans, block_group);
1045        if (ret)
1046                goto out;
1047
1048        ret = remove_block_group_item(trans, path, block_group);
1049        if (ret < 0)
1050                goto out;
1051
1052        spin_lock(&block_group->lock);
1053        block_group->removed = 1;
1054        /*
1055         * At this point trimming or scrub can't start on this block group,
1056         * because we removed the block group from the rbtree
1057         * fs_info->block_group_cache_tree so no one can't find it anymore and
1058         * even if someone already got this block group before we removed it
1059         * from the rbtree, they have already incremented block_group->frozen -
1060         * if they didn't, for the trimming case they won't find any free space
1061         * entries because we already removed them all when we called
1062         * btrfs_remove_free_space_cache().
1063         *
1064         * And we must not remove the extent map from the fs_info->mapping_tree
1065         * to prevent the same logical address range and physical device space
1066         * ranges from being reused for a new block group. This is needed to
1067         * avoid races with trimming and scrub.
1068         *
1069         * An fs trim operation (btrfs_trim_fs() / btrfs_ioctl_fitrim()) is
1070         * completely transactionless, so while it is trimming a range the
1071         * currently running transaction might finish and a new one start,
1072         * allowing for new block groups to be created that can reuse the same
1073         * physical device locations unless we take this special care.
1074         *
1075         * There may also be an implicit trim operation if the file system
1076         * is mounted with -odiscard. The same protections must remain
1077         * in place until the extents have been discarded completely when
1078         * the transaction commit has completed.
1079         */
1080        remove_em = (atomic_read(&block_group->frozen) == 0);
1081        spin_unlock(&block_group->lock);
1082
1083        if (remove_em) {
1084                struct extent_map_tree *em_tree;
1085
1086                em_tree = &fs_info->mapping_tree;
1087                write_lock(&em_tree->lock);
1088                remove_extent_mapping(em_tree, em);
1089                write_unlock(&em_tree->lock);
1090                /* once for the tree */
1091                free_extent_map(em);
1092        }
1093
1094out:
1095        /* Once for the lookup reference */
1096        btrfs_put_block_group(block_group);
1097        if (remove_rsv)
1098                btrfs_delayed_refs_rsv_release(fs_info, 1);
1099        btrfs_free_path(path);
1100        return ret;
1101}
1102
1103struct btrfs_trans_handle *btrfs_start_trans_remove_block_group(
1104                struct btrfs_fs_info *fs_info, const u64 chunk_offset)
1105{
1106        struct extent_map_tree *em_tree = &fs_info->mapping_tree;
1107        struct extent_map *em;
1108        struct map_lookup *map;
1109        unsigned int num_items;
1110
1111        read_lock(&em_tree->lock);
1112        em = lookup_extent_mapping(em_tree, chunk_offset, 1);
1113        read_unlock(&em_tree->lock);
1114        ASSERT(em && em->start == chunk_offset);
1115
1116        /*
1117         * We need to reserve 3 + N units from the metadata space info in order
1118         * to remove a block group (done at btrfs_remove_chunk() and at
1119         * btrfs_remove_block_group()), which are used for:
1120         *
1121         * 1 unit for adding the free space inode's orphan (located in the tree
1122         * of tree roots).
1123         * 1 unit for deleting the block group item (located in the extent
1124         * tree).
1125         * 1 unit for deleting the free space item (located in tree of tree
1126         * roots).
1127         * N units for deleting N device extent items corresponding to each
1128         * stripe (located in the device tree).
1129         *
1130         * In order to remove a block group we also need to reserve units in the
1131         * system space info in order to update the chunk tree (update one or
1132         * more device items and remove one chunk item), but this is done at
1133         * btrfs_remove_chunk() through a call to check_system_chunk().
1134         */
1135        map = em->map_lookup;
1136        num_items = 3 + map->num_stripes;
1137        free_extent_map(em);
1138
1139        return btrfs_start_transaction_fallback_global_rsv(fs_info->extent_root,
1140                                                           num_items);
1141}
1142
1143/*
1144 * Mark block group @cache read-only, so later write won't happen to block
1145 * group @cache.
1146 *
1147 * If @force is not set, this function will only mark the block group readonly
1148 * if we have enough free space (1M) in other metadata/system block groups.
1149 * If @force is not set, this function will mark the block group readonly
1150 * without checking free space.
1151 *
1152 * NOTE: This function doesn't care if other block groups can contain all the
1153 * data in this block group. That check should be done by relocation routine,
1154 * not this function.
1155 */
1156static int inc_block_group_ro(struct btrfs_block_group *cache, int force)
1157{
1158        struct btrfs_space_info *sinfo = cache->space_info;
1159        u64 num_bytes;
1160        int ret = -ENOSPC;
1161
1162        spin_lock(&sinfo->lock);
1163        spin_lock(&cache->lock);
1164
1165        if (cache->swap_extents) {
1166                ret = -ETXTBSY;
1167                goto out;
1168        }
1169
1170        if (cache->ro) {
1171                cache->ro++;
1172                ret = 0;
1173                goto out;
1174        }
1175
1176        num_bytes = cache->length - cache->reserved - cache->pinned -
1177                    cache->bytes_super - cache->zone_unusable - cache->used;
1178
1179        /*
1180         * Data never overcommits, even in mixed mode, so do just the straight
1181         * check of left over space in how much we have allocated.
1182         */
1183        if (force) {
1184                ret = 0;
1185        } else if (sinfo->flags & BTRFS_BLOCK_GROUP_DATA) {
1186                u64 sinfo_used = btrfs_space_info_used(sinfo, true);
1187
1188                /*
1189                 * Here we make sure if we mark this bg RO, we still have enough
1190                 * free space as buffer.
1191                 */
1192                if (sinfo_used + num_bytes <= sinfo->total_bytes)
1193                        ret = 0;
1194        } else {
1195                /*
1196                 * We overcommit metadata, so we need to do the
1197                 * btrfs_can_overcommit check here, and we need to pass in
1198                 * BTRFS_RESERVE_NO_FLUSH to give ourselves the most amount of
1199                 * leeway to allow us to mark this block group as read only.
1200                 */
1201                if (btrfs_can_overcommit(cache->fs_info, sinfo, num_bytes,
1202                                         BTRFS_RESERVE_NO_FLUSH))
1203                        ret = 0;
1204        }
1205
1206        if (!ret) {
1207                sinfo->bytes_readonly += num_bytes;
1208                if (btrfs_is_zoned(cache->fs_info)) {
1209                        /* Migrate zone_unusable bytes to readonly */
1210                        sinfo->bytes_readonly += cache->zone_unusable;
1211                        sinfo->bytes_zone_unusable -= cache->zone_unusable;
1212                        cache->zone_unusable = 0;
1213                }
1214                cache->ro++;
1215                list_add_tail(&cache->ro_list, &sinfo->ro_bgs);
1216        }
1217out:
1218        spin_unlock(&cache->lock);
1219        spin_unlock(&sinfo->lock);
1220        if (ret == -ENOSPC && btrfs_test_opt(cache->fs_info, ENOSPC_DEBUG)) {
1221                btrfs_info(cache->fs_info,
1222                        "unable to make block group %llu ro", cache->start);
1223                btrfs_dump_space_info(cache->fs_info, cache->space_info, 0, 0);
1224        }
1225        return ret;
1226}
1227
1228static bool clean_pinned_extents(struct btrfs_trans_handle *trans,
1229                                 struct btrfs_block_group *bg)
1230{
1231        struct btrfs_fs_info *fs_info = bg->fs_info;
1232        struct btrfs_transaction *prev_trans = NULL;
1233        const u64 start = bg->start;
1234        const u64 end = start + bg->length - 1;
1235        int ret;
1236
1237        spin_lock(&fs_info->trans_lock);
1238        if (trans->transaction->list.prev != &fs_info->trans_list) {
1239                prev_trans = list_last_entry(&trans->transaction->list,
1240                                             struct btrfs_transaction, list);
1241                refcount_inc(&prev_trans->use_count);
1242        }
1243        spin_unlock(&fs_info->trans_lock);
1244
1245        /*
1246         * Hold the unused_bg_unpin_mutex lock to avoid racing with
1247         * btrfs_finish_extent_commit(). If we are at transaction N, another
1248         * task might be running finish_extent_commit() for the previous
1249         * transaction N - 1, and have seen a range belonging to the block
1250         * group in pinned_extents before we were able to clear the whole block
1251         * group range from pinned_extents. This means that task can lookup for
1252         * the block group after we unpinned it from pinned_extents and removed
1253         * it, leading to a BUG_ON() at unpin_extent_range().
1254         */
1255        mutex_lock(&fs_info->unused_bg_unpin_mutex);
1256        if (prev_trans) {
1257                ret = clear_extent_bits(&prev_trans->pinned_extents, start, end,
1258                                        EXTENT_DIRTY);
1259                if (ret)
1260                        goto out;
1261        }
1262
1263        ret = clear_extent_bits(&trans->transaction->pinned_extents, start, end,
1264                                EXTENT_DIRTY);
1265out:
1266        mutex_unlock(&fs_info->unused_bg_unpin_mutex);
1267        if (prev_trans)
1268                btrfs_put_transaction(prev_trans);
1269
1270        return ret == 0;
1271}
1272
1273/*
1274 * Process the unused_bgs list and remove any that don't have any allocated
1275 * space inside of them.
1276 */
1277void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)
1278{
1279        struct btrfs_block_group *block_group;
1280        struct btrfs_space_info *space_info;
1281        struct btrfs_trans_handle *trans;
1282        const bool async_trim_enabled = btrfs_test_opt(fs_info, DISCARD_ASYNC);
1283        int ret = 0;
1284
1285        if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags))
1286                return;
1287
1288        /*
1289         * Long running balances can keep us blocked here for eternity, so
1290         * simply skip deletion if we're unable to get the mutex.
1291         */
1292        if (!mutex_trylock(&fs_info->reclaim_bgs_lock))
1293                return;
1294
1295        spin_lock(&fs_info->unused_bgs_lock);
1296        while (!list_empty(&fs_info->unused_bgs)) {
1297                int trimming;
1298
1299                block_group = list_first_entry(&fs_info->unused_bgs,
1300                                               struct btrfs_block_group,
1301                                               bg_list);
1302                list_del_init(&block_group->bg_list);
1303
1304                space_info = block_group->space_info;
1305
1306                if (ret || btrfs_mixed_space_info(space_info)) {
1307                        btrfs_put_block_group(block_group);
1308                        continue;
1309                }
1310                spin_unlock(&fs_info->unused_bgs_lock);
1311
1312                btrfs_discard_cancel_work(&fs_info->discard_ctl, block_group);
1313
1314                /* Don't want to race with allocators so take the groups_sem */
1315                down_write(&space_info->groups_sem);
1316
1317                /*
1318                 * Async discard moves the final block group discard to be prior
1319                 * to the unused_bgs code path.  Therefore, if it's not fully
1320                 * trimmed, punt it back to the async discard lists.
1321                 */
1322                if (btrfs_test_opt(fs_info, DISCARD_ASYNC) &&
1323                    !btrfs_is_free_space_trimmed(block_group)) {
1324                        trace_btrfs_skip_unused_block_group(block_group);
1325                        up_write(&space_info->groups_sem);
1326                        /* Requeue if we failed because of async discard */
1327                        btrfs_discard_queue_work(&fs_info->discard_ctl,
1328                                                 block_group);
1329                        goto next;
1330                }
1331
1332                spin_lock(&block_group->lock);
1333                if (block_group->reserved || block_group->pinned ||
1334                    block_group->used || block_group->ro ||
1335                    list_is_singular(&block_group->list)) {
1336                        /*
1337                         * We want to bail if we made new allocations or have
1338                         * outstanding allocations in this block group.  We do
1339                         * the ro check in case balance is currently acting on
1340                         * this block group.
1341                         */
1342                        trace_btrfs_skip_unused_block_group(block_group);
1343                        spin_unlock(&block_group->lock);
1344                        up_write(&space_info->groups_sem);
1345                        goto next;
1346                }
1347                spin_unlock(&block_group->lock);
1348
1349                /* We don't want to force the issue, only flip if it's ok. */
1350                ret = inc_block_group_ro(block_group, 0);
1351                up_write(&space_info->groups_sem);
1352                if (ret < 0) {
1353                        ret = 0;
1354                        goto next;
1355                }
1356
1357                /*
1358                 * Want to do this before we do anything else so we can recover
1359                 * properly if we fail to join the transaction.
1360                 */
1361                trans = btrfs_start_trans_remove_block_group(fs_info,
1362                                                     block_group->start);
1363                if (IS_ERR(trans)) {
1364                        btrfs_dec_block_group_ro(block_group);
1365                        ret = PTR_ERR(trans);
1366                        goto next;
1367                }
1368
1369                /*
1370                 * We could have pending pinned extents for this block group,
1371                 * just delete them, we don't care about them anymore.
1372                 */
1373                if (!clean_pinned_extents(trans, block_group)) {
1374                        btrfs_dec_block_group_ro(block_group);
1375                        goto end_trans;
1376                }
1377
1378                /*
1379                 * At this point, the block_group is read only and should fail
1380                 * new allocations.  However, btrfs_finish_extent_commit() can
1381                 * cause this block_group to be placed back on the discard
1382                 * lists because now the block_group isn't fully discarded.
1383                 * Bail here and try again later after discarding everything.
1384                 */
1385                spin_lock(&fs_info->discard_ctl.lock);
1386                if (!list_empty(&block_group->discard_list)) {
1387                        spin_unlock(&fs_info->discard_ctl.lock);
1388                        btrfs_dec_block_group_ro(block_group);
1389                        btrfs_discard_queue_work(&fs_info->discard_ctl,
1390                                                 block_group);
1391                        goto end_trans;
1392                }
1393                spin_unlock(&fs_info->discard_ctl.lock);
1394
1395                /* Reset pinned so btrfs_put_block_group doesn't complain */
1396                spin_lock(&space_info->lock);
1397                spin_lock(&block_group->lock);
1398
1399                btrfs_space_info_update_bytes_pinned(fs_info, space_info,
1400                                                     -block_group->pinned);
1401                space_info->bytes_readonly += block_group->pinned;
1402                block_group->pinned = 0;
1403
1404                spin_unlock(&block_group->lock);
1405                spin_unlock(&space_info->lock);
1406
1407                /*
1408                 * The normal path here is an unused block group is passed here,
1409                 * then trimming is handled in the transaction commit path.
1410                 * Async discard interposes before this to do the trimming
1411                 * before coming down the unused block group path as trimming
1412                 * will no longer be done later in the transaction commit path.
1413                 */
1414                if (!async_trim_enabled && btrfs_test_opt(fs_info, DISCARD_ASYNC))
1415                        goto flip_async;
1416
1417                /*
1418                 * DISCARD can flip during remount. On zoned filesystems, we
1419                 * need to reset sequential-required zones.
1420                 */
1421                trimming = btrfs_test_opt(fs_info, DISCARD_SYNC) ||
1422                                btrfs_is_zoned(fs_info);
1423
1424                /* Implicit trim during transaction commit. */
1425                if (trimming)
1426                        btrfs_freeze_block_group(block_group);
1427
1428                /*
1429                 * Btrfs_remove_chunk will abort the transaction if things go
1430                 * horribly wrong.
1431                 */
1432                ret = btrfs_remove_chunk(trans, block_group->start);
1433
1434                if (ret) {
1435                        if (trimming)
1436                                btrfs_unfreeze_block_group(block_group);
1437                        goto end_trans;
1438                }
1439
1440                /*
1441                 * If we're not mounted with -odiscard, we can just forget
1442                 * about this block group. Otherwise we'll need to wait
1443                 * until transaction commit to do the actual discard.
1444                 */
1445                if (trimming) {
1446                        spin_lock(&fs_info->unused_bgs_lock);
1447                        /*
1448                         * A concurrent scrub might have added us to the list
1449                         * fs_info->unused_bgs, so use a list_move operation
1450                         * to add the block group to the deleted_bgs list.
1451                         */
1452                        list_move(&block_group->bg_list,
1453                                  &trans->transaction->deleted_bgs);
1454                        spin_unlock(&fs_info->unused_bgs_lock);
1455                        btrfs_get_block_group(block_group);
1456                }
1457end_trans:
1458                btrfs_end_transaction(trans);
1459next:
1460                btrfs_put_block_group(block_group);
1461                spin_lock(&fs_info->unused_bgs_lock);
1462        }
1463        spin_unlock(&fs_info->unused_bgs_lock);
1464        mutex_unlock(&fs_info->reclaim_bgs_lock);
1465        return;
1466
1467flip_async:
1468        btrfs_end_transaction(trans);
1469        mutex_unlock(&fs_info->reclaim_bgs_lock);
1470        btrfs_put_block_group(block_group);
1471        btrfs_discard_punt_unused_bgs_list(fs_info);
1472}
1473
1474void btrfs_mark_bg_unused(struct btrfs_block_group *bg)
1475{
1476        struct btrfs_fs_info *fs_info = bg->fs_info;
1477
1478        spin_lock(&fs_info->unused_bgs_lock);
1479        if (list_empty(&bg->bg_list)) {
1480                btrfs_get_block_group(bg);
1481                trace_btrfs_add_unused_block_group(bg);
1482                list_add_tail(&bg->bg_list, &fs_info->unused_bgs);
1483        }
1484        spin_unlock(&fs_info->unused_bgs_lock);
1485}
1486
1487void btrfs_reclaim_bgs_work(struct work_struct *work)
1488{
1489        struct btrfs_fs_info *fs_info =
1490                container_of(work, struct btrfs_fs_info, reclaim_bgs_work);
1491        struct btrfs_block_group *bg;
1492        struct btrfs_space_info *space_info;
1493        LIST_HEAD(again_list);
1494
1495        if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags))
1496                return;
1497
1498        if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE))
1499                return;
1500
1501        /*
1502         * Long running balances can keep us blocked here for eternity, so
1503         * simply skip reclaim if we're unable to get the mutex.
1504         */
1505        if (!mutex_trylock(&fs_info->reclaim_bgs_lock)) {
1506                btrfs_exclop_finish(fs_info);
1507                return;
1508        }
1509
1510        spin_lock(&fs_info->unused_bgs_lock);
1511        while (!list_empty(&fs_info->reclaim_bgs)) {
1512                u64 zone_unusable;
1513                int ret = 0;
1514
1515                bg = list_first_entry(&fs_info->reclaim_bgs,
1516                                      struct btrfs_block_group,
1517                                      bg_list);
1518                list_del_init(&bg->bg_list);
1519
1520                space_info = bg->space_info;
1521                spin_unlock(&fs_info->unused_bgs_lock);
1522
1523                /* Don't race with allocators so take the groups_sem */
1524                down_write(&space_info->groups_sem);
1525
1526                spin_lock(&bg->lock);
1527                if (bg->reserved || bg->pinned || bg->ro) {
1528                        /*
1529                         * We want to bail if we made new allocations or have
1530                         * outstanding allocations in this block group.  We do
1531                         * the ro check in case balance is currently acting on
1532                         * this block group.
1533                         */
1534                        spin_unlock(&bg->lock);
1535                        up_write(&space_info->groups_sem);
1536                        goto next;
1537                }
1538                spin_unlock(&bg->lock);
1539
1540                /* Get out fast, in case we're unmounting the filesystem */
1541                if (btrfs_fs_closing(fs_info)) {
1542                        up_write(&space_info->groups_sem);
1543                        goto next;
1544                }
1545
1546                /*
1547                 * Cache the zone_unusable value before turning the block group
1548                 * to read only. As soon as the blog group is read only it's
1549                 * zone_unusable value gets moved to the block group's read-only
1550                 * bytes and isn't available for calculations anymore.
1551                 */
1552                zone_unusable = bg->zone_unusable;
1553                ret = inc_block_group_ro(bg, 0);
1554                up_write(&space_info->groups_sem);
1555                if (ret < 0)
1556                        goto next;
1557
1558                btrfs_info(fs_info,
1559                        "reclaiming chunk %llu with %llu%% used %llu%% unusable",
1560                                bg->start, div_u64(bg->used * 100, bg->length),
1561                                div64_u64(zone_unusable * 100, bg->length));
1562                trace_btrfs_reclaim_block_group(bg);
1563                ret = btrfs_relocate_chunk(fs_info, bg->start);
1564                if (ret)
1565                        btrfs_err(fs_info, "error relocating chunk %llu",
1566                                  bg->start);
1567
1568next:
1569                spin_lock(&fs_info->unused_bgs_lock);
1570                if (ret == -EAGAIN && list_empty(&bg->bg_list))
1571                        list_add_tail(&bg->bg_list, &again_list);
1572                else
1573                        btrfs_put_block_group(bg);
1574        }
1575        list_splice_tail(&again_list, &fs_info->reclaim_bgs);
1576        spin_unlock(&fs_info->unused_bgs_lock);
1577        mutex_unlock(&fs_info->reclaim_bgs_lock);
1578        btrfs_exclop_finish(fs_info);
1579}
1580
1581void btrfs_reclaim_bgs(struct btrfs_fs_info *fs_info)
1582{
1583        spin_lock(&fs_info->unused_bgs_lock);
1584        if (!list_empty(&fs_info->reclaim_bgs))
1585                queue_work(system_unbound_wq, &fs_info->reclaim_bgs_work);
1586        spin_unlock(&fs_info->unused_bgs_lock);
1587}
1588
1589void btrfs_mark_bg_to_reclaim(struct btrfs_block_group *bg)
1590{
1591        struct btrfs_fs_info *fs_info = bg->fs_info;
1592
1593        spin_lock(&fs_info->unused_bgs_lock);
1594        if (list_empty(&bg->bg_list)) {
1595                btrfs_get_block_group(bg);
1596                trace_btrfs_add_reclaim_block_group(bg);
1597                list_add_tail(&bg->bg_list, &fs_info->reclaim_bgs);
1598        }
1599        spin_unlock(&fs_info->unused_bgs_lock);
1600}
1601
1602static int read_bg_from_eb(struct btrfs_fs_info *fs_info, struct btrfs_key *key,
1603                           struct btrfs_path *path)
1604{
1605        struct extent_map_tree *em_tree;
1606        struct extent_map *em;
1607        struct btrfs_block_group_item bg;
1608        struct extent_buffer *leaf;
1609        int slot;
1610        u64 flags;
1611        int ret = 0;
1612
1613        slot = path->slots[0];
1614        leaf = path->nodes[0];
1615
1616        em_tree = &fs_info->mapping_tree;
1617        read_lock(&em_tree->lock);
1618        em = lookup_extent_mapping(em_tree, key->objectid, key->offset);
1619        read_unlock(&em_tree->lock);
1620        if (!em) {
1621                btrfs_err(fs_info,
1622                          "logical %llu len %llu found bg but no related chunk",
1623                          key->objectid, key->offset);
1624                return -ENOENT;
1625        }
1626
1627        if (em->start != key->objectid || em->len != key->offset) {
1628                btrfs_err(fs_info,
1629                        "block group %llu len %llu mismatch with chunk %llu len %llu",
1630                        key->objectid, key->offset, em->start, em->len);
1631                ret = -EUCLEAN;
1632                goto out_free_em;
1633        }
1634
1635        read_extent_buffer(leaf, &bg, btrfs_item_ptr_offset(leaf, slot),
1636                           sizeof(bg));
1637        flags = btrfs_stack_block_group_flags(&bg) &
1638                BTRFS_BLOCK_GROUP_TYPE_MASK;
1639
1640        if (flags != (em->map_lookup->type & BTRFS_BLOCK_GROUP_TYPE_MASK)) {
1641                btrfs_err(fs_info,
1642"block group %llu len %llu type flags 0x%llx mismatch with chunk type flags 0x%llx",
1643                          key->objectid, key->offset, flags,
1644                          (BTRFS_BLOCK_GROUP_TYPE_MASK & em->map_lookup->type));
1645                ret = -EUCLEAN;
1646        }
1647
1648out_free_em:
1649        free_extent_map(em);
1650        return ret;
1651}
1652
1653static int find_first_block_group(struct btrfs_fs_info *fs_info,
1654                                  struct btrfs_path *path,
1655                                  struct btrfs_key *key)
1656{
1657        struct btrfs_root *root = fs_info->extent_root;
1658        int ret;
1659        struct btrfs_key found_key;
1660        struct extent_buffer *leaf;
1661        int slot;
1662
1663        ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
1664        if (ret < 0)
1665                return ret;
1666
1667        while (1) {
1668                slot = path->slots[0];
1669                leaf = path->nodes[0];
1670                if (slot >= btrfs_header_nritems(leaf)) {
1671                        ret = btrfs_next_leaf(root, path);
1672                        if (ret == 0)
1673                                continue;
1674                        if (ret < 0)
1675                                goto out;
1676                        break;
1677                }
1678                btrfs_item_key_to_cpu(leaf, &found_key, slot);
1679
1680                if (found_key.objectid >= key->objectid &&
1681                    found_key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
1682                        ret = read_bg_from_eb(fs_info, &found_key, path);
1683                        break;
1684                }
1685
1686                path->slots[0]++;
1687        }
1688out:
1689        return ret;
1690}
1691
1692static void set_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)
1693{
1694        u64 extra_flags = chunk_to_extended(flags) &
1695                                BTRFS_EXTENDED_PROFILE_MASK;
1696
1697        write_seqlock(&fs_info->profiles_lock);
1698        if (flags & BTRFS_BLOCK_GROUP_DATA)
1699                fs_info->avail_data_alloc_bits |= extra_flags;
1700        if (flags & BTRFS_BLOCK_GROUP_METADATA)
1701                fs_info->avail_metadata_alloc_bits |= extra_flags;
1702        if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
1703                fs_info->avail_system_alloc_bits |= extra_flags;
1704        write_sequnlock(&fs_info->profiles_lock);
1705}
1706
1707/**
1708 * Map a physical disk address to a list of logical addresses
1709 *
1710 * @fs_info:       the filesystem
1711 * @chunk_start:   logical address of block group
1712 * @bdev:          physical device to resolve, can be NULL to indicate any device
1713 * @physical:      physical address to map to logical addresses
1714 * @logical:       return array of logical addresses which map to @physical
1715 * @naddrs:        length of @logical
1716 * @stripe_len:    size of IO stripe for the given block group
1717 *
1718 * Maps a particular @physical disk address to a list of @logical addresses.
1719 * Used primarily to exclude those portions of a block group that contain super
1720 * block copies.
1721 */
1722int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,
1723                     struct block_device *bdev, u64 physical, u64 **logical,
1724                     int *naddrs, int *stripe_len)
1725{
1726        struct extent_map *em;
1727        struct map_lookup *map;
1728        u64 *buf;
1729        u64 bytenr;
1730        u64 data_stripe_length;
1731        u64 io_stripe_size;
1732        int i, nr = 0;
1733        int ret = 0;
1734
1735        em = btrfs_get_chunk_map(fs_info, chunk_start, 1);
1736        if (IS_ERR(em))
1737                return -EIO;
1738
1739        map = em->map_lookup;
1740        data_stripe_length = em->orig_block_len;
1741        io_stripe_size = map->stripe_len;
1742        chunk_start = em->start;
1743
1744        /* For RAID5/6 adjust to a full IO stripe length */
1745        if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK)
1746                io_stripe_size = map->stripe_len * nr_data_stripes(map);
1747
1748        buf = kcalloc(map->num_stripes, sizeof(u64), GFP_NOFS);
1749        if (!buf) {
1750                ret = -ENOMEM;
1751                goto out;
1752        }
1753
1754        for (i = 0; i < map->num_stripes; i++) {
1755                bool already_inserted = false;
1756                u64 stripe_nr;
1757                u64 offset;
1758                int j;
1759
1760                if (!in_range(physical, map->stripes[i].physical,
1761                              data_stripe_length))
1762                        continue;
1763
1764                if (bdev && map->stripes[i].dev->bdev != bdev)
1765                        continue;
1766
1767                stripe_nr = physical - map->stripes[i].physical;
1768                stripe_nr = div64_u64_rem(stripe_nr, map->stripe_len, &offset);
1769
1770                if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
1771                        stripe_nr = stripe_nr * map->num_stripes + i;
1772                        stripe_nr = div_u64(stripe_nr, map->sub_stripes);
1773                } else if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
1774                        stripe_nr = stripe_nr * map->num_stripes + i;
1775                }
1776                /*
1777                 * The remaining case would be for RAID56, multiply by
1778                 * nr_data_stripes().  Alternatively, just use rmap_len below
1779                 * instead of map->stripe_len
1780                 */
1781
1782                bytenr = chunk_start + stripe_nr * io_stripe_size + offset;
1783
1784                /* Ensure we don't add duplicate addresses */
1785                for (j = 0; j < nr; j++) {
1786                        if (buf[j] == bytenr) {
1787                                already_inserted = true;
1788                                break;
1789                        }
1790                }
1791
1792                if (!already_inserted)
1793                        buf[nr++] = bytenr;
1794        }
1795
1796        *logical = buf;
1797        *naddrs = nr;
1798        *stripe_len = io_stripe_size;
1799out:
1800        free_extent_map(em);
1801        return ret;
1802}
1803
1804static int exclude_super_stripes(struct btrfs_block_group *cache)
1805{
1806        struct btrfs_fs_info *fs_info = cache->fs_info;
1807        const bool zoned = btrfs_is_zoned(fs_info);
1808        u64 bytenr;
1809        u64 *logical;
1810        int stripe_len;
1811        int i, nr, ret;
1812
1813        if (cache->start < BTRFS_SUPER_INFO_OFFSET) {
1814                stripe_len = BTRFS_SUPER_INFO_OFFSET - cache->start;
1815                cache->bytes_super += stripe_len;
1816                ret = btrfs_add_excluded_extent(fs_info, cache->start,
1817                                                stripe_len);
1818                if (ret)
1819                        return ret;
1820        }
1821
1822        for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
1823                bytenr = btrfs_sb_offset(i);
1824                ret = btrfs_rmap_block(fs_info, cache->start, NULL,
1825                                       bytenr, &logical, &nr, &stripe_len);
1826                if (ret)
1827                        return ret;
1828
1829                /* Shouldn't have super stripes in sequential zones */
1830                if (zoned && nr) {
1831                        btrfs_err(fs_info,
1832                        "zoned: block group %llu must not contain super block",
1833                                  cache->start);
1834                        return -EUCLEAN;
1835                }
1836
1837                while (nr--) {
1838                        u64 len = min_t(u64, stripe_len,
1839                                cache->start + cache->length - logical[nr]);
1840
1841                        cache->bytes_super += len;
1842                        ret = btrfs_add_excluded_extent(fs_info, logical[nr],
1843                                                        len);
1844                        if (ret) {
1845                                kfree(logical);
1846                                return ret;
1847                        }
1848                }
1849
1850                kfree(logical);
1851        }
1852        return 0;
1853}
1854
1855static void link_block_group(struct btrfs_block_group *cache)
1856{
1857        struct btrfs_space_info *space_info = cache->space_info;
1858        int index = btrfs_bg_flags_to_raid_index(cache->flags);
1859
1860        down_write(&space_info->groups_sem);
1861        list_add_tail(&cache->list, &space_info->block_groups[index]);
1862        up_write(&space_info->groups_sem);
1863}
1864
1865static struct btrfs_block_group *btrfs_create_block_group_cache(
1866                struct btrfs_fs_info *fs_info, u64 start)
1867{
1868        struct btrfs_block_group *cache;
1869
1870        cache = kzalloc(sizeof(*cache), GFP_NOFS);
1871        if (!cache)
1872                return NULL;
1873
1874        cache->free_space_ctl = kzalloc(sizeof(*cache->free_space_ctl),
1875                                        GFP_NOFS);
1876        if (!cache->free_space_ctl) {
1877                kfree(cache);
1878                return NULL;
1879        }
1880
1881        cache->start = start;
1882
1883        cache->fs_info = fs_info;
1884        cache->full_stripe_len = btrfs_full_stripe_len(fs_info, start);
1885
1886        cache->discard_index = BTRFS_DISCARD_INDEX_UNUSED;
1887
1888        refcount_set(&cache->refs, 1);
1889        spin_lock_init(&cache->lock);
1890        init_rwsem(&cache->data_rwsem);
1891        INIT_LIST_HEAD(&cache->list);
1892        INIT_LIST_HEAD(&cache->cluster_list);
1893        INIT_LIST_HEAD(&cache->bg_list);
1894        INIT_LIST_HEAD(&cache->ro_list);
1895        INIT_LIST_HEAD(&cache->discard_list);
1896        INIT_LIST_HEAD(&cache->dirty_list);
1897        INIT_LIST_HEAD(&cache->io_list);
1898        btrfs_init_free_space_ctl(cache, cache->free_space_ctl);
1899        atomic_set(&cache->frozen, 0);
1900        mutex_init(&cache->free_space_lock);
1901        btrfs_init_full_stripe_locks_tree(&cache->full_stripe_locks_root);
1902
1903        return cache;
1904}
1905
1906/*
1907 * Iterate all chunks and verify that each of them has the corresponding block
1908 * group
1909 */
1910static int check_chunk_block_group_mappings(struct btrfs_fs_info *fs_info)
1911{
1912        struct extent_map_tree *map_tree = &fs_info->mapping_tree;
1913        struct extent_map *em;
1914        struct btrfs_block_group *bg;
1915        u64 start = 0;
1916        int ret = 0;
1917
1918        while (1) {
1919                read_lock(&map_tree->lock);
1920                /*
1921                 * lookup_extent_mapping will return the first extent map
1922                 * intersecting the range, so setting @len to 1 is enough to
1923                 * get the first chunk.
1924                 */
1925                em = lookup_extent_mapping(map_tree, start, 1);
1926                read_unlock(&map_tree->lock);
1927                if (!em)
1928                        break;
1929
1930                bg = btrfs_lookup_block_group(fs_info, em->start);
1931                if (!bg) {
1932                        btrfs_err(fs_info,
1933        "chunk start=%llu len=%llu doesn't have corresponding block group",
1934                                     em->start, em->len);
1935                        ret = -EUCLEAN;
1936                        free_extent_map(em);
1937                        break;
1938                }
1939                if (bg->start != em->start || bg->length != em->len ||
1940                    (bg->flags & BTRFS_BLOCK_GROUP_TYPE_MASK) !=
1941                    (em->map_lookup->type & BTRFS_BLOCK_GROUP_TYPE_MASK)) {
1942                        btrfs_err(fs_info,
1943"chunk start=%llu len=%llu flags=0x%llx doesn't match block group start=%llu len=%llu flags=0x%llx",
1944                                em->start, em->len,
1945                                em->map_lookup->type & BTRFS_BLOCK_GROUP_TYPE_MASK,
1946                                bg->start, bg->length,
1947                                bg->flags & BTRFS_BLOCK_GROUP_TYPE_MASK);
1948                        ret = -EUCLEAN;
1949                        free_extent_map(em);
1950                        btrfs_put_block_group(bg);
1951                        break;
1952                }
1953                start = em->start + em->len;
1954                free_extent_map(em);
1955                btrfs_put_block_group(bg);
1956        }
1957        return ret;
1958}
1959
1960static int read_one_block_group(struct btrfs_fs_info *info,
1961                                struct btrfs_block_group_item *bgi,
1962                                const struct btrfs_key *key,
1963                                int need_clear)
1964{
1965        struct btrfs_block_group *cache;
1966        struct btrfs_space_info *space_info;
1967        const bool mixed = btrfs_fs_incompat(info, MIXED_GROUPS);
1968        int ret;
1969
1970        ASSERT(key->type == BTRFS_BLOCK_GROUP_ITEM_KEY);
1971
1972        cache = btrfs_create_block_group_cache(info, key->objectid);
1973        if (!cache)
1974                return -ENOMEM;
1975
1976        cache->length = key->offset;
1977        cache->used = btrfs_stack_block_group_used(bgi);
1978        cache->flags = btrfs_stack_block_group_flags(bgi);
1979
1980        set_free_space_tree_thresholds(cache);
1981
1982        if (need_clear) {
1983                /*
1984                 * When we mount with old space cache, we need to
1985                 * set BTRFS_DC_CLEAR and set dirty flag.
1986                 *
1987                 * a) Setting 'BTRFS_DC_CLEAR' makes sure that we
1988                 *    truncate the old free space cache inode and
1989                 *    setup a new one.
1990                 * b) Setting 'dirty flag' makes sure that we flush
1991                 *    the new space cache info onto disk.
1992                 */
1993                if (btrfs_test_opt(info, SPACE_CACHE))
1994                        cache->disk_cache_state = BTRFS_DC_CLEAR;
1995        }
1996        if (!mixed && ((cache->flags & BTRFS_BLOCK_GROUP_METADATA) &&
1997            (cache->flags & BTRFS_BLOCK_GROUP_DATA))) {
1998                        btrfs_err(info,
1999"bg %llu is a mixed block group but filesystem hasn't enabled mixed block groups",
2000                                  cache->start);
2001                        ret = -EINVAL;
2002                        goto error;
2003        }
2004
2005        ret = btrfs_load_block_group_zone_info(cache, false);
2006        if (ret) {
2007                btrfs_err(info, "zoned: failed to load zone info of bg %llu",
2008                          cache->start);
2009                goto error;
2010        }
2011
2012        /*
2013         * We need to exclude the super stripes now so that the space info has
2014         * super bytes accounted for, otherwise we'll think we have more space
2015         * than we actually do.
2016         */
2017        ret = exclude_super_stripes(cache);
2018        if (ret) {
2019                /* We may have excluded something, so call this just in case. */
2020                btrfs_free_excluded_extents(cache);
2021                goto error;
2022        }
2023
2024        /*
2025         * For zoned filesystem, space after the allocation offset is the only
2026         * free space for a block group. So, we don't need any caching work.
2027         * btrfs_calc_zone_unusable() will set the amount of free space and
2028         * zone_unusable space.
2029         *
2030         * For regular filesystem, check for two cases, either we are full, and
2031         * therefore don't need to bother with the caching work since we won't
2032         * find any space, or we are empty, and we can just add all the space
2033         * in and be done with it.  This saves us _a_lot_ of time, particularly
2034         * in the full case.
2035         */
2036        if (btrfs_is_zoned(info)) {
2037                btrfs_calc_zone_unusable(cache);
2038        } else if (cache->length == cache->used) {
2039                cache->last_byte_to_unpin = (u64)-1;
2040                cache->cached = BTRFS_CACHE_FINISHED;
2041                btrfs_free_excluded_extents(cache);
2042        } else if (cache->used == 0) {
2043                cache->last_byte_to_unpin = (u64)-1;
2044                cache->cached = BTRFS_CACHE_FINISHED;
2045                add_new_free_space(cache, cache->start,
2046                                   cache->start + cache->length);
2047                btrfs_free_excluded_extents(cache);
2048        }
2049
2050        ret = btrfs_add_block_group_cache(info, cache);
2051        if (ret) {
2052                btrfs_remove_free_space_cache(cache);
2053                goto error;
2054        }
2055        trace_btrfs_add_block_group(info, cache, 0);
2056        btrfs_update_space_info(info, cache->flags, cache->length,
2057                                cache->used, cache->bytes_super,
2058                                cache->zone_unusable, &space_info);
2059
2060        cache->space_info = space_info;
2061
2062        link_block_group(cache);
2063
2064        set_avail_alloc_bits(info, cache->flags);
2065        if (btrfs_chunk_readonly(info, cache->start)) {
2066                inc_block_group_ro(cache, 1);
2067        } else if (cache->used == 0) {
2068                ASSERT(list_empty(&cache->bg_list));
2069                if (btrfs_test_opt(info, DISCARD_ASYNC))
2070                        btrfs_discard_queue_work(&info->discard_ctl, cache);
2071                else
2072                        btrfs_mark_bg_unused(cache);
2073        }
2074        return 0;
2075error:
2076        btrfs_put_block_group(cache);
2077        return ret;
2078}
2079
2080static int fill_dummy_bgs(struct btrfs_fs_info *fs_info)
2081{
2082        struct extent_map_tree *em_tree = &fs_info->mapping_tree;
2083        struct btrfs_space_info *space_info;
2084        struct rb_node *node;
2085        int ret = 0;
2086
2087        for (node = rb_first_cached(&em_tree->map); node; node = rb_next(node)) {
2088                struct extent_map *em;
2089                struct map_lookup *map;
2090                struct btrfs_block_group *bg;
2091
2092                em = rb_entry(node, struct extent_map, rb_node);
2093                map = em->map_lookup;
2094                bg = btrfs_create_block_group_cache(fs_info, em->start);
2095                if (!bg) {
2096                        ret = -ENOMEM;
2097                        break;
2098                }
2099
2100                /* Fill dummy cache as FULL */
2101                bg->length = em->len;
2102                bg->flags = map->type;
2103                bg->last_byte_to_unpin = (u64)-1;
2104                bg->cached = BTRFS_CACHE_FINISHED;
2105                bg->used = em->len;
2106                bg->flags = map->type;
2107                ret = btrfs_add_block_group_cache(fs_info, bg);
2108                if (ret) {
2109                        btrfs_remove_free_space_cache(bg);
2110                        btrfs_put_block_group(bg);
2111                        break;
2112                }
2113                btrfs_update_space_info(fs_info, bg->flags, em->len, em->len,
2114                                        0, 0, &space_info);
2115                bg->space_info = space_info;
2116                link_block_group(bg);
2117
2118                set_avail_alloc_bits(fs_info, bg->flags);
2119        }
2120        if (!ret)
2121                btrfs_init_global_block_rsv(fs_info);
2122        return ret;
2123}
2124
2125int btrfs_read_block_groups(struct btrfs_fs_info *info)
2126{
2127        struct btrfs_path *path;
2128        int ret;
2129        struct btrfs_block_group *cache;
2130        struct btrfs_space_info *space_info;
2131        struct btrfs_key key;
2132        int need_clear = 0;
2133        u64 cache_gen;
2134
2135        if (!info->extent_root)
2136                return fill_dummy_bgs(info);
2137
2138        key.objectid = 0;
2139        key.offset = 0;
2140        key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
2141        path = btrfs_alloc_path();
2142        if (!path)
2143                return -ENOMEM;
2144
2145        cache_gen = btrfs_super_cache_generation(info->super_copy);
2146        if (btrfs_test_opt(info, SPACE_CACHE) &&
2147            btrfs_super_generation(info->super_copy) != cache_gen)
2148                need_clear = 1;
2149        if (btrfs_test_opt(info, CLEAR_CACHE))
2150                need_clear = 1;
2151
2152        while (1) {
2153                struct btrfs_block_group_item bgi;
2154                struct extent_buffer *leaf;
2155                int slot;
2156
2157                ret = find_first_block_group(info, path, &key);
2158                if (ret > 0)
2159                        break;
2160                if (ret != 0)
2161                        goto error;
2162
2163                leaf = path->nodes[0];
2164                slot = path->slots[0];
2165
2166                read_extent_buffer(leaf, &bgi, btrfs_item_ptr_offset(leaf, slot),
2167                                   sizeof(bgi));
2168
2169                btrfs_item_key_to_cpu(leaf, &key, slot);
2170                btrfs_release_path(path);
2171                ret = read_one_block_group(info, &bgi, &key, need_clear);
2172                if (ret < 0)
2173                        goto error;
2174                key.objectid += key.offset;
2175                key.offset = 0;
2176        }
2177        btrfs_release_path(path);
2178
2179        list_for_each_entry(space_info, &info->space_info, list) {
2180                int i;
2181
2182                for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) {
2183                        if (list_empty(&space_info->block_groups[i]))
2184                                continue;
2185                        cache = list_first_entry(&space_info->block_groups[i],
2186                                                 struct btrfs_block_group,
2187                                                 list);
2188                        btrfs_sysfs_add_block_group_type(cache);
2189                }
2190
2191                if (!(btrfs_get_alloc_profile(info, space_info->flags) &
2192                      (BTRFS_BLOCK_GROUP_RAID10 |
2193                       BTRFS_BLOCK_GROUP_RAID1_MASK |
2194                       BTRFS_BLOCK_GROUP_RAID56_MASK |
2195                       BTRFS_BLOCK_GROUP_DUP)))
2196                        continue;
2197                /*
2198                 * Avoid allocating from un-mirrored block group if there are
2199                 * mirrored block groups.
2200                 */
2201                list_for_each_entry(cache,
2202                                &space_info->block_groups[BTRFS_RAID_RAID0],
2203                                list)
2204                        inc_block_group_ro(cache, 1);
2205                list_for_each_entry(cache,
2206                                &space_info->block_groups[BTRFS_RAID_SINGLE],
2207                                list)
2208                        inc_block_group_ro(cache, 1);
2209        }
2210
2211        btrfs_init_global_block_rsv(info);
2212        ret = check_chunk_block_group_mappings(info);
2213error:
2214        btrfs_free_path(path);
2215        return ret;
2216}
2217
2218/*
2219 * This function, insert_block_group_item(), belongs to the phase 2 of chunk
2220 * allocation.
2221 *
2222 * See the comment at btrfs_chunk_alloc() for details about the chunk allocation
2223 * phases.
2224 */
2225static int insert_block_group_item(struct btrfs_trans_handle *trans,
2226                                   struct btrfs_block_group *block_group)
2227{
2228        struct btrfs_fs_info *fs_info = trans->fs_info;
2229        struct btrfs_block_group_item bgi;
2230        struct btrfs_root *root;
2231        struct btrfs_key key;
2232
2233        spin_lock(&block_group->lock);
2234        btrfs_set_stack_block_group_used(&bgi, block_group->used);
2235        btrfs_set_stack_block_group_chunk_objectid(&bgi,
2236                                BTRFS_FIRST_CHUNK_TREE_OBJECTID);
2237        btrfs_set_stack_block_group_flags(&bgi, block_group->flags);
2238        key.objectid = block_group->start;
2239        key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
2240        key.offset = block_group->length;
2241        spin_unlock(&block_group->lock);
2242
2243        root = fs_info->extent_root;
2244        return btrfs_insert_item(trans, root, &key, &bgi, sizeof(bgi));
2245}
2246
2247/*
2248 * This function, btrfs_create_pending_block_groups(), belongs to the phase 2 of
2249 * chunk allocation.
2250 *
2251 * See the comment at btrfs_chunk_alloc() for details about the chunk allocation
2252 * phases.
2253 */
2254void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans)
2255{
2256        struct btrfs_fs_info *fs_info = trans->fs_info;
2257        struct btrfs_block_group *block_group;
2258        int ret = 0;
2259
2260        while (!list_empty(&trans->new_bgs)) {
2261                int index;
2262
2263                block_group = list_first_entry(&trans->new_bgs,
2264                                               struct btrfs_block_group,
2265                                               bg_list);
2266                if (ret)
2267                        goto next;
2268
2269                index = btrfs_bg_flags_to_raid_index(block_group->flags);
2270
2271                ret = insert_block_group_item(trans, block_group);
2272                if (ret)
2273                        btrfs_abort_transaction(trans, ret);
2274                if (!block_group->chunk_item_inserted) {
2275                        mutex_lock(&fs_info->chunk_mutex);
2276                        ret = btrfs_chunk_alloc_add_chunk_item(trans, block_group);
2277                        mutex_unlock(&fs_info->chunk_mutex);
2278                        if (ret)
2279                                btrfs_abort_transaction(trans, ret);
2280                }
2281                ret = btrfs_finish_chunk_alloc(trans, block_group->start,
2282                                        block_group->length);
2283                if (ret)
2284                        btrfs_abort_transaction(trans, ret);
2285                add_block_group_free_space(trans, block_group);
2286
2287                /*
2288                 * If we restriped during balance, we may have added a new raid
2289                 * type, so now add the sysfs entries when it is safe to do so.
2290                 * We don't have to worry about locking here as it's handled in
2291                 * btrfs_sysfs_add_block_group_type.
2292                 */
2293                if (block_group->space_info->block_group_kobjs[index] == NULL)
2294                        btrfs_sysfs_add_block_group_type(block_group);
2295
2296                /* Already aborted the transaction if it failed. */
2297next:
2298                btrfs_delayed_refs_rsv_release(fs_info, 1);
2299                list_del_init(&block_group->bg_list);
2300        }
2301        btrfs_trans_release_chunk_metadata(trans);
2302}
2303
2304struct btrfs_block_group *btrfs_make_block_group(struct btrfs_trans_handle *trans,
2305                                                 u64 bytes_used, u64 type,
2306                                                 u64 chunk_offset, u64 size)
2307{
2308        struct btrfs_fs_info *fs_info = trans->fs_info;
2309        struct btrfs_block_group *cache;
2310        int ret;
2311
2312        btrfs_set_log_full_commit(trans);
2313
2314        cache = btrfs_create_block_group_cache(fs_info, chunk_offset);
2315        if (!cache)
2316                return ERR_PTR(-ENOMEM);
2317
2318        cache->length = size;
2319        set_free_space_tree_thresholds(cache);
2320        cache->used = bytes_used;
2321        cache->flags = type;
2322        cache->last_byte_to_unpin = (u64)-1;
2323        cache->cached = BTRFS_CACHE_FINISHED;
2324        if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE))
2325                cache->needs_free_space = 1;
2326
2327        ret = btrfs_load_block_group_zone_info(cache, true);
2328        if (ret) {
2329                btrfs_put_block_group(cache);
2330                return ERR_PTR(ret);
2331        }
2332
2333        ret = exclude_super_stripes(cache);
2334        if (ret) {
2335                /* We may have excluded something, so call this just in case */
2336                btrfs_free_excluded_extents(cache);
2337                btrfs_put_block_group(cache);
2338                return ERR_PTR(ret);
2339        }
2340
2341        add_new_free_space(cache, chunk_offset, chunk_offset + size);
2342
2343        btrfs_free_excluded_extents(cache);
2344
2345#ifdef CONFIG_BTRFS_DEBUG
2346        if (btrfs_should_fragment_free_space(cache)) {
2347                u64 new_bytes_used = size - bytes_used;
2348
2349                bytes_used += new_bytes_used >> 1;
2350                fragment_free_space(cache);
2351        }
2352#endif
2353        /*
2354         * Ensure the corresponding space_info object is created and
2355         * assigned to our block group. We want our bg to be added to the rbtree
2356         * with its ->space_info set.
2357         */
2358        cache->space_info = btrfs_find_space_info(fs_info, cache->flags);
2359        ASSERT(cache->space_info);
2360
2361        ret = btrfs_add_block_group_cache(fs_info, cache);
2362        if (ret) {
2363                btrfs_remove_free_space_cache(cache);
2364                btrfs_put_block_group(cache);
2365                return ERR_PTR(ret);
2366        }
2367
2368        /*
2369         * Now that our block group has its ->space_info set and is inserted in
2370         * the rbtree, update the space info's counters.
2371         */
2372        trace_btrfs_add_block_group(fs_info, cache, 1);
2373        btrfs_update_space_info(fs_info, cache->flags, size, bytes_used,
2374                                cache->bytes_super, 0, &cache->space_info);
2375        btrfs_update_global_block_rsv(fs_info);
2376
2377        link_block_group(cache);
2378
2379        list_add_tail(&cache->bg_list, &trans->new_bgs);
2380        trans->delayed_ref_updates++;
2381        btrfs_update_delayed_refs_rsv(trans);
2382
2383        set_avail_alloc_bits(fs_info, type);
2384        return cache;
2385}
2386
2387/*
2388 * Mark one block group RO, can be called several times for the same block
2389 * group.
2390 *
2391 * @cache:              the destination block group
2392 * @do_chunk_alloc:     whether need to do chunk pre-allocation, this is to
2393 *                      ensure we still have some free space after marking this
2394 *                      block group RO.
2395 */
2396int btrfs_inc_block_group_ro(struct btrfs_block_group *cache,
2397                             bool do_chunk_alloc)
2398{
2399        struct btrfs_fs_info *fs_info = cache->fs_info;
2400        struct btrfs_trans_handle *trans;
2401        u64 alloc_flags;
2402        int ret;
2403        bool dirty_bg_running;
2404
2405        do {
2406                trans = btrfs_join_transaction(fs_info->extent_root);
2407                if (IS_ERR(trans))
2408                        return PTR_ERR(trans);
2409
2410                dirty_bg_running = false;
2411
2412                /*
2413                 * We're not allowed to set block groups readonly after the dirty
2414                 * block group cache has started writing.  If it already started,
2415                 * back off and let this transaction commit.
2416                 */
2417                mutex_lock(&fs_info->ro_block_group_mutex);
2418                if (test_bit(BTRFS_TRANS_DIRTY_BG_RUN, &trans->transaction->flags)) {
2419                        u64 transid = trans->transid;
2420
2421                        mutex_unlock(&fs_info->ro_block_group_mutex);
2422                        btrfs_end_transaction(trans);
2423
2424                        ret = btrfs_wait_for_commit(fs_info, transid);
2425                        if (ret)
2426                                return ret;
2427                        dirty_bg_running = true;
2428                }
2429        } while (dirty_bg_running);
2430
2431        if (do_chunk_alloc) {
2432                /*
2433                 * If we are changing raid levels, try to allocate a
2434                 * corresponding block group with the new raid level.
2435                 */
2436                alloc_flags = btrfs_get_alloc_profile(fs_info, cache->flags);
2437                if (alloc_flags != cache->flags) {
2438                        ret = btrfs_chunk_alloc(trans, alloc_flags,
2439                                                CHUNK_ALLOC_FORCE);
2440                        /*
2441                         * ENOSPC is allowed here, we may have enough space
2442                         * already allocated at the new raid level to carry on
2443                         */
2444                        if (ret == -ENOSPC)
2445                                ret = 0;
2446                        if (ret < 0)
2447                                goto out;
2448                }
2449        }
2450
2451        ret = inc_block_group_ro(cache, 0);
2452        if (!do_chunk_alloc || ret == -ETXTBSY)
2453                goto unlock_out;
2454        if (!ret)
2455                goto out;
2456        alloc_flags = btrfs_get_alloc_profile(fs_info, cache->space_info->flags);
2457        ret = btrfs_chunk_alloc(trans, alloc_flags, CHUNK_ALLOC_FORCE);
2458        if (ret < 0)
2459                goto out;
2460        ret = inc_block_group_ro(cache, 0);
2461        if (ret == -ETXTBSY)
2462                goto unlock_out;
2463out:
2464        if (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM) {
2465                alloc_flags = btrfs_get_alloc_profile(fs_info, cache->flags);
2466                mutex_lock(&fs_info->chunk_mutex);
2467                check_system_chunk(trans, alloc_flags);
2468                mutex_unlock(&fs_info->chunk_mutex);
2469        }
2470unlock_out:
2471        mutex_unlock(&fs_info->ro_block_group_mutex);
2472
2473        btrfs_end_transaction(trans);
2474        return ret;
2475}
2476
2477void btrfs_dec_block_group_ro(struct btrfs_block_group *cache)
2478{
2479        struct btrfs_space_info *sinfo = cache->space_info;
2480        u64 num_bytes;
2481
2482        BUG_ON(!cache->ro);
2483
2484        spin_lock(&sinfo->lock);
2485        spin_lock(&cache->lock);
2486        if (!--cache->ro) {
2487                if (btrfs_is_zoned(cache->fs_info)) {
2488                        /* Migrate zone_unusable bytes back */
2489                        cache->zone_unusable = cache->alloc_offset - cache->used;
2490                        sinfo->bytes_zone_unusable += cache->zone_unusable;
2491                        sinfo->bytes_readonly -= cache->zone_unusable;
2492                }
2493                num_bytes = cache->length - cache->reserved -
2494                            cache->pinned - cache->bytes_super -
2495                            cache->zone_unusable - cache->used;
2496                sinfo->bytes_readonly -= num_bytes;
2497                list_del_init(&cache->ro_list);
2498        }
2499        spin_unlock(&cache->lock);
2500        spin_unlock(&sinfo->lock);
2501}
2502
2503static int update_block_group_item(struct btrfs_trans_handle *trans,
2504                                   struct btrfs_path *path,
2505                                   struct btrfs_block_group *cache)
2506{
2507        struct btrfs_fs_info *fs_info = trans->fs_info;
2508        int ret;
2509        struct btrfs_root *root = fs_info->extent_root;
2510        unsigned long bi;
2511        struct extent_buffer *leaf;
2512        struct btrfs_block_group_item bgi;
2513        struct btrfs_key key;
2514
2515        key.objectid = cache->start;
2516        key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
2517        key.offset = cache->length;
2518
2519        ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2520        if (ret) {
2521                if (ret > 0)
2522                        ret = -ENOENT;
2523                goto fail;
2524        }
2525
2526        leaf = path->nodes[0];
2527        bi = btrfs_item_ptr_offset(leaf, path->slots[0]);
2528        btrfs_set_stack_block_group_used(&bgi, cache->used);
2529        btrfs_set_stack_block_group_chunk_objectid(&bgi,
2530                        BTRFS_FIRST_CHUNK_TREE_OBJECTID);
2531        btrfs_set_stack_block_group_flags(&bgi, cache->flags);
2532        write_extent_buffer(leaf, &bgi, bi, sizeof(bgi));
2533        btrfs_mark_buffer_dirty(leaf);
2534fail:
2535        btrfs_release_path(path);
2536        return ret;
2537
2538}
2539
2540static int cache_save_setup(struct btrfs_block_group *block_group,
2541                            struct btrfs_trans_handle *trans,
2542                            struct btrfs_path *path)
2543{
2544        struct btrfs_fs_info *fs_info = block_group->fs_info;
2545        struct btrfs_root *root = fs_info->tree_root;
2546        struct inode *inode = NULL;
2547        struct extent_changeset *data_reserved = NULL;
2548        u64 alloc_hint = 0;
2549        int dcs = BTRFS_DC_ERROR;
2550        u64 cache_size = 0;
2551        int retries = 0;
2552        int ret = 0;
2553
2554        if (!btrfs_test_opt(fs_info, SPACE_CACHE))
2555                return 0;
2556
2557        /*
2558         * If this block group is smaller than 100 megs don't bother caching the
2559         * block group.
2560         */
2561        if (block_group->length < (100 * SZ_1M)) {
2562                spin_lock(&block_group->lock);
2563                block_group->disk_cache_state = BTRFS_DC_WRITTEN;
2564                spin_unlock(&block_group->lock);
2565                return 0;
2566        }
2567
2568        if (TRANS_ABORTED(trans))
2569                return 0;
2570again:
2571        inode = lookup_free_space_inode(block_group, path);
2572        if (IS_ERR(inode) && PTR_ERR(inode) != -ENOENT) {
2573                ret = PTR_ERR(inode);
2574                btrfs_release_path(path);
2575                goto out;
2576        }
2577
2578        if (IS_ERR(inode)) {
2579                BUG_ON(retries);
2580                retries++;
2581
2582                if (block_group->ro)
2583                        goto out_free;
2584
2585                ret = create_free_space_inode(trans, block_group, path);
2586                if (ret)
2587                        goto out_free;
2588                goto again;
2589        }
2590
2591        /*
2592         * We want to set the generation to 0, that way if anything goes wrong
2593         * from here on out we know not to trust this cache when we load up next
2594         * time.
2595         */
2596        BTRFS_I(inode)->generation = 0;
2597        ret = btrfs_update_inode(trans, root, BTRFS_I(inode));
2598        if (ret) {
2599                /*
2600                 * So theoretically we could recover from this, simply set the
2601                 * super cache generation to 0 so we know to invalidate the
2602                 * cache, but then we'd have to keep track of the block groups
2603                 * that fail this way so we know we _have_ to reset this cache
2604                 * before the next commit or risk reading stale cache.  So to
2605                 * limit our exposure to horrible edge cases lets just abort the
2606                 * transaction, this only happens in really bad situations
2607                 * anyway.
2608                 */
2609                btrfs_abort_transaction(trans, ret);
2610                goto out_put;
2611        }
2612        WARN_ON(ret);
2613
2614        /* We've already setup this transaction, go ahead and exit */
2615        if (block_group->cache_generation == trans->transid &&
2616            i_size_read(inode)) {
2617                dcs = BTRFS_DC_SETUP;
2618                goto out_put;
2619        }
2620
2621        if (i_size_read(inode) > 0) {
2622                ret = btrfs_check_trunc_cache_free_space(fs_info,
2623                                        &fs_info->global_block_rsv);
2624                if (ret)
2625                        goto out_put;
2626
2627                ret = btrfs_truncate_free_space_cache(trans, NULL, inode);
2628                if (ret)
2629                        goto out_put;
2630        }
2631
2632        spin_lock(&block_group->lock);
2633        if (block_group->cached != BTRFS_CACHE_FINISHED ||
2634            !btrfs_test_opt(fs_info, SPACE_CACHE)) {
2635                /*
2636                 * don't bother trying to write stuff out _if_
2637                 * a) we're not cached,
2638                 * b) we're with nospace_cache mount option,
2639                 * c) we're with v2 space_cache (FREE_SPACE_TREE).
2640                 */
2641                dcs = BTRFS_DC_WRITTEN;
2642                spin_unlock(&block_group->lock);
2643                goto out_put;
2644        }
2645        spin_unlock(&block_group->lock);
2646
2647        /*
2648         * We hit an ENOSPC when setting up the cache in this transaction, just
2649         * skip doing the setup, we've already cleared the cache so we're safe.
2650         */
2651        if (test_bit(BTRFS_TRANS_CACHE_ENOSPC, &trans->transaction->flags)) {
2652                ret = -ENOSPC;
2653                goto out_put;
2654        }
2655
2656        /*
2657         * Try to preallocate enough space based on how big the block group is.
2658         * Keep in mind this has to include any pinned space which could end up
2659         * taking up quite a bit since it's not folded into the other space
2660         * cache.
2661         */
2662        cache_size = div_u64(block_group->length, SZ_256M);
2663        if (!cache_size)
2664                cache_size = 1;
2665
2666        cache_size *= 16;
2667        cache_size *= fs_info->sectorsize;
2668
2669        ret = btrfs_check_data_free_space(BTRFS_I(inode), &data_reserved, 0,
2670                                          cache_size);
2671        if (ret)
2672                goto out_put;
2673
2674        ret = btrfs_prealloc_file_range_trans(inode, trans, 0, 0, cache_size,
2675                                              cache_size, cache_size,
2676                                              &alloc_hint);
2677        /*
2678         * Our cache requires contiguous chunks so that we don't modify a bunch
2679         * of metadata or split extents when writing the cache out, which means
2680         * we can enospc if we are heavily fragmented in addition to just normal
2681         * out of space conditions.  So if we hit this just skip setting up any
2682         * other block groups for this transaction, maybe we'll unpin enough
2683         * space the next time around.
2684         */
2685        if (!ret)
2686                dcs = BTRFS_DC_SETUP;
2687        else if (ret == -ENOSPC)
2688                set_bit(BTRFS_TRANS_CACHE_ENOSPC, &trans->transaction->flags);
2689
2690out_put:
2691        iput(inode);
2692out_free:
2693        btrfs_release_path(path);
2694out:
2695        spin_lock(&block_group->lock);
2696        if (!ret && dcs == BTRFS_DC_SETUP)
2697                block_group->cache_generation = trans->transid;
2698        block_group->disk_cache_state = dcs;
2699        spin_unlock(&block_group->lock);
2700
2701        extent_changeset_free(data_reserved);
2702        return ret;
2703}
2704
2705int btrfs_setup_space_cache(struct btrfs_trans_handle *trans)
2706{
2707        struct btrfs_fs_info *fs_info = trans->fs_info;
2708        struct btrfs_block_group *cache, *tmp;
2709        struct btrfs_transaction *cur_trans = trans->transaction;
2710        struct btrfs_path *path;
2711
2712        if (list_empty(&cur_trans->dirty_bgs) ||
2713            !btrfs_test_opt(fs_info, SPACE_CACHE))
2714                return 0;
2715
2716        path = btrfs_alloc_path();
2717        if (!path)
2718                return -ENOMEM;
2719
2720        /* Could add new block groups, use _safe just in case */
2721        list_for_each_entry_safe(cache, tmp, &cur_trans->dirty_bgs,
2722                                 dirty_list) {
2723                if (cache->disk_cache_state == BTRFS_DC_CLEAR)
2724                        cache_save_setup(cache, trans, path);
2725        }
2726
2727        btrfs_free_path(path);
2728        return 0;
2729}
2730
2731/*
2732 * Transaction commit does final block group cache writeback during a critical
2733 * section where nothing is allowed to change the FS.  This is required in
2734 * order for the cache to actually match the block group, but can introduce a
2735 * lot of latency into the commit.
2736 *
2737 * So, btrfs_start_dirty_block_groups is here to kick off block group cache IO.
2738 * There's a chance we'll have to redo some of it if the block group changes
2739 * again during the commit, but it greatly reduces the commit latency by
2740 * getting rid of the easy block groups while we're still allowing others to
2741 * join the commit.
2742 */
2743int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans)
2744{
2745        struct btrfs_fs_info *fs_info = trans->fs_info;
2746        struct btrfs_block_group *cache;
2747        struct btrfs_transaction *cur_trans = trans->transaction;
2748        int ret = 0;
2749        int should_put;
2750        struct btrfs_path *path = NULL;
2751        LIST_HEAD(dirty);
2752        struct list_head *io = &cur_trans->io_bgs;
2753        int num_started = 0;
2754        int loops = 0;
2755
2756        spin_lock(&cur_trans->dirty_bgs_lock);
2757        if (list_empty(&cur_trans->dirty_bgs)) {
2758                spin_unlock(&cur_trans->dirty_bgs_lock);
2759                return 0;
2760        }
2761        list_splice_init(&cur_trans->dirty_bgs, &dirty);
2762        spin_unlock(&cur_trans->dirty_bgs_lock);
2763
2764again:
2765        /* Make sure all the block groups on our dirty list actually exist */
2766        btrfs_create_pending_block_groups(trans);
2767
2768        if (!path) {
2769                path = btrfs_alloc_path();
2770                if (!path) {
2771                        ret = -ENOMEM;
2772                        goto out;
2773                }
2774        }
2775
2776        /*
2777         * cache_write_mutex is here only to save us from balance or automatic
2778         * removal of empty block groups deleting this block group while we are
2779         * writing out the cache
2780         */
2781        mutex_lock(&trans->transaction->cache_write_mutex);
2782        while (!list_empty(&dirty)) {
2783                bool drop_reserve = true;
2784
2785                cache = list_first_entry(&dirty, struct btrfs_block_group,
2786                                         dirty_list);
2787                /*
2788                 * This can happen if something re-dirties a block group that
2789                 * is already under IO.  Just wait for it to finish and then do
2790                 * it all again
2791                 */
2792                if (!list_empty(&cache->io_list)) {
2793                        list_del_init(&cache->io_list);
2794                        btrfs_wait_cache_io(trans, cache, path);
2795                        btrfs_put_block_group(cache);
2796                }
2797
2798
2799                /*
2800                 * btrfs_wait_cache_io uses the cache->dirty_list to decide if
2801                 * it should update the cache_state.  Don't delete until after
2802                 * we wait.
2803                 *
2804                 * Since we're not running in the commit critical section
2805                 * we need the dirty_bgs_lock to protect from update_block_group
2806                 */
2807                spin_lock(&cur_trans->dirty_bgs_lock);
2808                list_del_init(&cache->dirty_list);
2809                spin_unlock(&cur_trans->dirty_bgs_lock);
2810
2811                should_put = 1;
2812
2813                cache_save_setup(cache, trans, path);
2814
2815                if (cache->disk_cache_state == BTRFS_DC_SETUP) {
2816                        cache->io_ctl.inode = NULL;
2817                        ret = btrfs_write_out_cache(trans, cache, path);
2818                        if (ret == 0 && cache->io_ctl.inode) {
2819                                num_started++;
2820                                should_put = 0;
2821
2822                                /*
2823                                 * The cache_write_mutex is protecting the
2824                                 * io_list, also refer to the definition of
2825                                 * btrfs_transaction::io_bgs for more details
2826                                 */
2827                                list_add_tail(&cache->io_list, io);
2828                        } else {
2829                                /*
2830                                 * If we failed to write the cache, the
2831                                 * generation will be bad and life goes on
2832                                 */
2833                                ret = 0;
2834                        }
2835                }
2836                if (!ret) {
2837                        ret = update_block_group_item(trans, path, cache);
2838                        /*
2839                         * Our block group might still be attached to the list
2840                         * of new block groups in the transaction handle of some
2841                         * other task (struct btrfs_trans_handle->new_bgs). This
2842                         * means its block group item isn't yet in the extent
2843                         * tree. If this happens ignore the error, as we will
2844                         * try again later in the critical section of the
2845                         * transaction commit.
2846                         */
2847                        if (ret == -ENOENT) {
2848                                ret = 0;
2849                                spin_lock(&cur_trans->dirty_bgs_lock);
2850                                if (list_empty(&cache->dirty_list)) {
2851                                        list_add_tail(&cache->dirty_list,
2852                                                      &cur_trans->dirty_bgs);
2853                                        btrfs_get_block_group(cache);
2854                                        drop_reserve = false;
2855                                }
2856                                spin_unlock(&cur_trans->dirty_bgs_lock);
2857                        } else if (ret) {
2858                                btrfs_abort_transaction(trans, ret);
2859                        }
2860                }
2861
2862                /* If it's not on the io list, we need to put the block group */
2863                if (should_put)
2864                        btrfs_put_block_group(cache);
2865                if (drop_reserve)
2866                        btrfs_delayed_refs_rsv_release(fs_info, 1);
2867                /*
2868                 * Avoid blocking other tasks for too long. It might even save
2869                 * us from writing caches for block groups that are going to be
2870                 * removed.
2871                 */
2872                mutex_unlock(&trans->transaction->cache_write_mutex);
2873                if (ret)
2874                        goto out;
2875                mutex_lock(&trans->transaction->cache_write_mutex);
2876        }
2877        mutex_unlock(&trans->transaction->cache_write_mutex);
2878
2879        /*
2880         * Go through delayed refs for all the stuff we've just kicked off
2881         * and then loop back (just once)
2882         */
2883        if (!ret)
2884                ret = btrfs_run_delayed_refs(trans, 0);
2885        if (!ret && loops == 0) {
2886                loops++;
2887                spin_lock(&cur_trans->dirty_bgs_lock);
2888                list_splice_init(&cur_trans->dirty_bgs, &dirty);
2889                /*
2890                 * dirty_bgs_lock protects us from concurrent block group
2891                 * deletes too (not just cache_write_mutex).
2892                 */
2893                if (!list_empty(&dirty)) {
2894                        spin_unlock(&cur_trans->dirty_bgs_lock);
2895                        goto again;
2896                }
2897                spin_unlock(&cur_trans->dirty_bgs_lock);
2898        }
2899out:
2900        if (ret < 0) {
2901                spin_lock(&cur_trans->dirty_bgs_lock);
2902                list_splice_init(&dirty, &cur_trans->dirty_bgs);
2903                spin_unlock(&cur_trans->dirty_bgs_lock);
2904                btrfs_cleanup_dirty_bgs(cur_trans, fs_info);
2905        }
2906
2907        btrfs_free_path(path);
2908        return ret;
2909}
2910
2911int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans)
2912{
2913        struct btrfs_fs_info *fs_info = trans->fs_info;
2914        struct btrfs_block_group *cache;
2915        struct btrfs_transaction *cur_trans = trans->transaction;
2916        int ret = 0;
2917        int should_put;
2918        struct btrfs_path *path;
2919        struct list_head *io = &cur_trans->io_bgs;
2920        int num_started = 0;
2921
2922        path = btrfs_alloc_path();
2923        if (!path)
2924                return -ENOMEM;
2925
2926        /*
2927         * Even though we are in the critical section of the transaction commit,
2928         * we can still have concurrent tasks adding elements to this
2929         * transaction's list of dirty block groups. These tasks correspond to
2930         * endio free space workers started when writeback finishes for a
2931         * space cache, which run inode.c:btrfs_finish_ordered_io(), and can
2932         * allocate new block groups as a result of COWing nodes of the root
2933         * tree when updating the free space inode. The writeback for the space
2934         * caches is triggered by an earlier call to
2935         * btrfs_start_dirty_block_groups() and iterations of the following
2936         * loop.
2937         * Also we want to do the cache_save_setup first and then run the
2938         * delayed refs to make sure we have the best chance at doing this all
2939         * in one shot.
2940         */
2941        spin_lock(&cur_trans->dirty_bgs_lock);
2942        while (!list_empty(&cur_trans->dirty_bgs)) {
2943                cache = list_first_entry(&cur_trans->dirty_bgs,
2944                                         struct btrfs_block_group,
2945                                         dirty_list);
2946
2947                /*
2948                 * This can happen if cache_save_setup re-dirties a block group
2949                 * that is already under IO.  Just wait for it to finish and
2950                 * then do it all again
2951                 */
2952                if (!list_empty(&cache->io_list)) {
2953                        spin_unlock(&cur_trans->dirty_bgs_lock);
2954                        list_del_init(&cache->io_list);
2955                        btrfs_wait_cache_io(trans, cache, path);
2956                        btrfs_put_block_group(cache);
2957                        spin_lock(&cur_trans->dirty_bgs_lock);
2958                }
2959
2960                /*
2961                 * Don't remove from the dirty list until after we've waited on
2962                 * any pending IO
2963                 */
2964                list_del_init(&cache->dirty_list);
2965                spin_unlock(&cur_trans->dirty_bgs_lock);
2966                should_put = 1;
2967
2968                cache_save_setup(cache, trans, path);
2969
2970                if (!ret)
2971                        ret = btrfs_run_delayed_refs(trans,
2972                                                     (unsigned long) -1);
2973
2974                if (!ret && cache->disk_cache_state == BTRFS_DC_SETUP) {
2975                        cache->io_ctl.inode = NULL;
2976                        ret = btrfs_write_out_cache(trans, cache, path);
2977                        if (ret == 0 && cache->io_ctl.inode) {
2978                                num_started++;
2979                                should_put = 0;
2980                                list_add_tail(&cache->io_list, io);
2981                        } else {
2982                                /*
2983                                 * If we failed to write the cache, the
2984                                 * generation will be bad and life goes on
2985                                 */
2986                                ret = 0;
2987                        }
2988                }
2989                if (!ret) {
2990                        ret = update_block_group_item(trans, path, cache);
2991                        /*
2992                         * One of the free space endio workers might have
2993                         * created a new block group while updating a free space
2994                         * cache's inode (at inode.c:btrfs_finish_ordered_io())
2995                         * and hasn't released its transaction handle yet, in
2996                         * which case the new block group is still attached to
2997                         * its transaction handle and its creation has not
2998                         * finished yet (no block group item in the extent tree
2999                         * yet, etc). If this is the case, wait for all free
3000                         * space endio workers to finish and retry. This is a
3001                         * very rare case so no need for a more efficient and
3002                         * complex approach.
3003                         */
3004                        if (ret == -ENOENT) {
3005                                wait_event(cur_trans->writer_wait,
3006                                   atomic_read(&cur_trans->num_writers) == 1);
3007                                ret = update_block_group_item(trans, path, cache);
3008                        }
3009                        if (ret)
3010                                btrfs_abort_transaction(trans, ret);
3011                }
3012
3013                /* If its not on the io list, we need to put the block group */
3014                if (should_put)
3015                        btrfs_put_block_group(cache);
3016                btrfs_delayed_refs_rsv_release(fs_info, 1);
3017                spin_lock(&cur_trans->dirty_bgs_lock);
3018        }
3019        spin_unlock(&cur_trans->dirty_bgs_lock);
3020
3021        /*
3022         * Refer to the definition of io_bgs member for details why it's safe
3023         * to use it without any locking
3024         */
3025        while (!list_empty(io)) {
3026                cache = list_first_entry(io, struct btrfs_block_group,
3027                                         io_list);
3028                list_del_init(&cache->io_list);
3029                btrfs_wait_cache_io(trans, cache, path);
3030                btrfs_put_block_group(cache);
3031        }
3032
3033        btrfs_free_path(path);
3034        return ret;
3035}
3036
3037int btrfs_update_block_group(struct btrfs_trans_handle *trans,
3038                             u64 bytenr, u64 num_bytes, int alloc)
3039{
3040        struct btrfs_fs_info *info = trans->fs_info;
3041        struct btrfs_block_group *cache = NULL;
3042        u64 total = num_bytes;
3043        u64 old_val;
3044        u64 byte_in_group;
3045        int factor;
3046        int ret = 0;
3047
3048        /* Block accounting for super block */
3049        spin_lock(&info->delalloc_root_lock);
3050        old_val = btrfs_super_bytes_used(info->super_copy);
3051        if (alloc)
3052                old_val += num_bytes;
3053        else
3054                old_val -= num_bytes;
3055        btrfs_set_super_bytes_used(info->super_copy, old_val);
3056        spin_unlock(&info->delalloc_root_lock);
3057
3058        while (total) {
3059                cache = btrfs_lookup_block_group(info, bytenr);
3060                if (!cache) {
3061                        ret = -ENOENT;
3062                        break;
3063                }
3064                factor = btrfs_bg_type_to_factor(cache->flags);
3065
3066                /*
3067                 * If this block group has free space cache written out, we
3068                 * need to make sure to load it if we are removing space.  This
3069                 * is because we need the unpinning stage to actually add the
3070                 * space back to the block group, otherwise we will leak space.
3071                 */
3072                if (!alloc && !btrfs_block_group_done(cache))
3073                        btrfs_cache_block_group(cache, 1);
3074
3075                byte_in_group = bytenr - cache->start;
3076                WARN_ON(byte_in_group > cache->length);
3077
3078                spin_lock(&cache->space_info->lock);
3079                spin_lock(&cache->lock);
3080
3081                if (btrfs_test_opt(info, SPACE_CACHE) &&
3082                    cache->disk_cache_state < BTRFS_DC_CLEAR)
3083                        cache->disk_cache_state = BTRFS_DC_CLEAR;
3084
3085                old_val = cache->used;
3086                num_bytes = min(total, cache->length - byte_in_group);
3087                if (alloc) {
3088                        old_val += num_bytes;
3089                        cache->used = old_val;
3090                        cache->reserved -= num_bytes;
3091                        cache->space_info->bytes_reserved -= num_bytes;
3092                        cache->space_info->bytes_used += num_bytes;
3093                        cache->space_info->disk_used += num_bytes * factor;
3094                        spin_unlock(&cache->lock);
3095                        spin_unlock(&cache->space_info->lock);
3096                } else {
3097                        old_val -= num_bytes;
3098                        cache->used = old_val;
3099                        cache->pinned += num_bytes;
3100                        btrfs_space_info_update_bytes_pinned(info,
3101                                        cache->space_info, num_bytes);
3102                        cache->space_info->bytes_used -= num_bytes;
3103                        cache->space_info->disk_used -= num_bytes * factor;
3104                        spin_unlock(&cache->lock);
3105                        spin_unlock(&cache->space_info->lock);
3106
3107                        set_extent_dirty(&trans->transaction->pinned_extents,
3108                                         bytenr, bytenr + num_bytes - 1,
3109                                         GFP_NOFS | __GFP_NOFAIL);
3110                }
3111
3112                spin_lock(&trans->transaction->dirty_bgs_lock);
3113                if (list_empty(&cache->dirty_list)) {
3114                        list_add_tail(&cache->dirty_list,
3115                                      &trans->transaction->dirty_bgs);
3116                        trans->delayed_ref_updates++;
3117                        btrfs_get_block_group(cache);
3118                }
3119                spin_unlock(&trans->transaction->dirty_bgs_lock);
3120
3121                /*
3122                 * No longer have used bytes in this block group, queue it for
3123                 * deletion. We do this after adding the block group to the
3124                 * dirty list to avoid races between cleaner kthread and space
3125                 * cache writeout.
3126                 */
3127                if (!alloc && old_val == 0) {
3128                        if (!btrfs_test_opt(info, DISCARD_ASYNC))
3129                                btrfs_mark_bg_unused(cache);
3130                }
3131
3132                btrfs_put_block_group(cache);
3133                total -= num_bytes;
3134                bytenr += num_bytes;
3135        }
3136
3137        /* Modified block groups are accounted for in the delayed_refs_rsv. */
3138        btrfs_update_delayed_refs_rsv(trans);
3139        return ret;
3140}
3141
3142/**
3143 * btrfs_add_reserved_bytes - update the block_group and space info counters
3144 * @cache:      The cache we are manipulating
3145 * @ram_bytes:  The number of bytes of file content, and will be same to
3146 *              @num_bytes except for the compress path.
3147 * @num_bytes:  The number of bytes in question
3148 * @delalloc:   The blocks are allocated for the delalloc write
3149 *
3150 * This is called by the allocator when it reserves space. If this is a
3151 * reservation and the block group has become read only we cannot make the
3152 * reservation and return -EAGAIN, otherwise this function always succeeds.
3153 */
3154int btrfs_add_reserved_bytes(struct btrfs_block_group *cache,
3155                             u64 ram_bytes, u64 num_bytes, int delalloc)
3156{
3157        struct btrfs_space_info *space_info = cache->space_info;
3158        int ret = 0;
3159
3160        spin_lock(&space_info->lock);
3161        spin_lock(&cache->lock);
3162        if (cache->ro) {
3163                ret = -EAGAIN;
3164        } else {
3165                cache->reserved += num_bytes;
3166                space_info->bytes_reserved += num_bytes;
3167                trace_btrfs_space_reservation(cache->fs_info, "space_info",
3168                                              space_info->flags, num_bytes, 1);
3169                btrfs_space_info_update_bytes_may_use(cache->fs_info,
3170                                                      space_info, -ram_bytes);
3171                if (delalloc)
3172                        cache->delalloc_bytes += num_bytes;
3173
3174                /*
3175                 * Compression can use less space than we reserved, so wake
3176                 * tickets if that happens
3177                 */
3178                if (num_bytes < ram_bytes)
3179                        btrfs_try_granting_tickets(cache->fs_info, space_info);
3180        }
3181        spin_unlock(&cache->lock);
3182        spin_unlock(&space_info->lock);
3183        return ret;
3184}
3185
3186/**
3187 * btrfs_free_reserved_bytes - update the block_group and space info counters
3188 * @cache:      The cache we are manipulating
3189 * @num_bytes:  The number of bytes in question
3190 * @delalloc:   The blocks are allocated for the delalloc write
3191 *
3192 * This is called by somebody who is freeing space that was never actually used
3193 * on disk.  For example if you reserve some space for a new leaf in transaction
3194 * A and before transaction A commits you free that leaf, you call this with
3195 * reserve set to 0 in order to clear the reservation.
3196 */
3197void btrfs_free_reserved_bytes(struct btrfs_block_group *cache,
3198                               u64 num_bytes, int delalloc)
3199{
3200        struct btrfs_space_info *space_info = cache->space_info;
3201
3202        spin_lock(&space_info->lock);
3203        spin_lock(&cache->lock);
3204        if (cache->ro)
3205                space_info->bytes_readonly += num_bytes;
3206        cache->reserved -= num_bytes;
3207        space_info->bytes_reserved -= num_bytes;
3208        space_info->max_extent_size = 0;
3209
3210        if (delalloc)
3211                cache->delalloc_bytes -= num_bytes;
3212        spin_unlock(&cache->lock);
3213
3214        btrfs_try_granting_tickets(cache->fs_info, space_info);
3215        spin_unlock(&space_info->lock);
3216}
3217
3218static void force_metadata_allocation(struct btrfs_fs_info *info)
3219{
3220        struct list_head *head = &info->space_info;
3221        struct btrfs_space_info *found;
3222
3223        list_for_each_entry(found, head, list) {
3224                if (found->flags & BTRFS_BLOCK_GROUP_METADATA)
3225                        found->force_alloc = CHUNK_ALLOC_FORCE;
3226        }
3227}
3228
3229static int should_alloc_chunk(struct btrfs_fs_info *fs_info,
3230                              struct btrfs_space_info *sinfo, int force)
3231{
3232        u64 bytes_used = btrfs_space_info_used(sinfo, false);
3233        u64 thresh;
3234
3235        if (force == CHUNK_ALLOC_FORCE)
3236                return 1;
3237
3238        /*
3239         * in limited mode, we want to have some free space up to
3240         * about 1% of the FS size.
3241         */
3242        if (force == CHUNK_ALLOC_LIMITED) {
3243                thresh = btrfs_super_total_bytes(fs_info->super_copy);
3244                thresh = max_t(u64, SZ_64M, div_factor_fine(thresh, 1));
3245
3246                if (sinfo->total_bytes - bytes_used < thresh)
3247                        return 1;
3248        }
3249
3250        if (bytes_used + SZ_2M < div_factor(sinfo->total_bytes, 8))
3251                return 0;
3252        return 1;
3253}
3254
3255int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans, u64 type)
3256{
3257        u64 alloc_flags = btrfs_get_alloc_profile(trans->fs_info, type);
3258
3259        return btrfs_chunk_alloc(trans, alloc_flags, CHUNK_ALLOC_FORCE);
3260}
3261
3262static int do_chunk_alloc(struct btrfs_trans_handle *trans, u64 flags)
3263{
3264        struct btrfs_block_group *bg;
3265        int ret;
3266
3267        /*
3268         * Check if we have enough space in the system space info because we
3269         * will need to update device items in the chunk btree and insert a new
3270         * chunk item in the chunk btree as well. This will allocate a new
3271         * system block group if needed.
3272         */
3273        check_system_chunk(trans, flags);
3274
3275        bg = btrfs_alloc_chunk(trans, flags);
3276        if (IS_ERR(bg)) {
3277                ret = PTR_ERR(bg);
3278                goto out;
3279        }
3280
3281        /*
3282         * If this is a system chunk allocation then stop right here and do not
3283         * add the chunk item to the chunk btree. This is to prevent a deadlock
3284         * because this system chunk allocation can be triggered while COWing
3285         * some extent buffer of the chunk btree and while holding a lock on a
3286         * parent extent buffer, in which case attempting to insert the chunk
3287         * item (or update the device item) would result in a deadlock on that
3288         * parent extent buffer. In this case defer the chunk btree updates to
3289         * the second phase of chunk allocation and keep our reservation until
3290         * the second phase completes.
3291         *
3292         * This is a rare case and can only be triggered by the very few cases
3293         * we have where we need to touch the chunk btree outside chunk allocation
3294         * and chunk removal. These cases are basically adding a device, removing
3295         * a device or resizing a device.
3296         */
3297        if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
3298                return 0;
3299
3300        ret = btrfs_chunk_alloc_add_chunk_item(trans, bg);
3301        /*
3302         * Normally we are not expected to fail with -ENOSPC here, since we have
3303         * previously reserved space in the system space_info and allocated one
3304         * new system chunk if necessary. However there are two exceptions:
3305         *
3306         * 1) We may have enough free space in the system space_info but all the
3307         *    existing system block groups have a profile which can not be used
3308         *    for extent allocation.
3309         *
3310         *    This happens when mounting in degraded mode. For example we have a
3311         *    RAID1 filesystem with 2 devices, lose one device and mount the fs
3312         *    using the other device in degraded mode. If we then allocate a chunk,
3313         *    we may have enough free space in the existing system space_info, but
3314         *    none of the block groups can be used for extent allocation since they
3315         *    have a RAID1 profile, and because we are in degraded mode with a
3316         *    single device, we are forced to allocate a new system chunk with a
3317         *    SINGLE profile. Making check_system_chunk() iterate over all system
3318         *    block groups and check if they have a usable profile and enough space
3319         *    can be slow on very large filesystems, so we tolerate the -ENOSPC and
3320         *    try again after forcing allocation of a new system chunk. Like this
3321         *    we avoid paying the cost of that search in normal circumstances, when
3322         *    we were not mounted in degraded mode;
3323         *
3324         * 2) We had enough free space info the system space_info, and one suitable
3325         *    block group to allocate from when we called check_system_chunk()
3326         *    above. However right after we called it, the only system block group
3327         *    with enough free space got turned into RO mode by a running scrub,
3328         *    and in this case we have to allocate a new one and retry. We only
3329         *    need do this allocate and retry once, since we have a transaction
3330         *    handle and scrub uses the commit root to search for block groups.
3331         */
3332        if (ret == -ENOSPC) {
3333                const u64 sys_flags = btrfs_system_alloc_profile(trans->fs_info);
3334                struct btrfs_block_group *sys_bg;
3335
3336                sys_bg = btrfs_alloc_chunk(trans, sys_flags);
3337                if (IS_ERR(sys_bg)) {
3338                        ret = PTR_ERR(sys_bg);
3339                        btrfs_abort_transaction(trans, ret);
3340                        goto out;
3341                }
3342
3343                ret = btrfs_chunk_alloc_add_chunk_item(trans, sys_bg);
3344                if (ret) {
3345                        btrfs_abort_transaction(trans, ret);
3346                        goto out;
3347                }
3348
3349                ret = btrfs_chunk_alloc_add_chunk_item(trans, bg);
3350                if (ret) {
3351                        btrfs_abort_transaction(trans, ret);
3352                        goto out;
3353                }
3354        } else if (ret) {
3355                btrfs_abort_transaction(trans, ret);
3356                goto out;
3357        }
3358out:
3359        btrfs_trans_release_chunk_metadata(trans);
3360
3361        return ret;
3362}
3363
3364/*
3365 * Chunk allocation is done in 2 phases:
3366 *
3367 * 1) Phase 1 - through btrfs_chunk_alloc() we allocate device extents for
3368 *    the chunk, the chunk mapping, create its block group and add the items
3369 *    that belong in the chunk btree to it - more specifically, we need to
3370 *    update device items in the chunk btree and add a new chunk item to it.
3371 *
3372 * 2) Phase 2 - through btrfs_create_pending_block_groups(), we add the block
3373 *    group item to the extent btree and the device extent items to the devices
3374 *    btree.
3375 *
3376 * This is done to prevent deadlocks. For example when COWing a node from the
3377 * extent btree we are holding a write lock on the node's parent and if we
3378 * trigger chunk allocation and attempted to insert the new block group item
3379 * in the extent btree right way, we could deadlock because the path for the
3380 * insertion can include that parent node. At first glance it seems impossible
3381 * to trigger chunk allocation after starting a transaction since tasks should
3382 * reserve enough transaction units (metadata space), however while that is true
3383 * most of the time, chunk allocation may still be triggered for several reasons:
3384 *
3385 * 1) When reserving metadata, we check if there is enough free space in the
3386 *    metadata space_info and therefore don't trigger allocation of a new chunk.
3387 *    However later when the task actually tries to COW an extent buffer from
3388 *    the extent btree or from the device btree for example, it is forced to
3389 *    allocate a new block group (chunk) because the only one that had enough
3390 *    free space was just turned to RO mode by a running scrub for example (or
3391 *    device replace, block group reclaim thread, etc), so we can not use it
3392 *    for allocating an extent and end up being forced to allocate a new one;
3393 *
3394 * 2) Because we only check that the metadata space_info has enough free bytes,
3395 *    we end up not allocating a new metadata chunk in that case. However if
3396 *    the filesystem was mounted in degraded mode, none of the existing block
3397 *    groups might be suitable for extent allocation due to their incompatible
3398 *    profile (for e.g. mounting a 2 devices filesystem, where all block groups
3399 *    use a RAID1 profile, in degraded mode using a single device). In this case
3400 *    when the task attempts to COW some extent buffer of the extent btree for
3401 *    example, it will trigger allocation of a new metadata block group with a
3402 *    suitable profile (SINGLE profile in the example of the degraded mount of
3403 *    the RAID1 filesystem);
3404 *
3405 * 3) The task has reserved enough transaction units / metadata space, but when
3406 *    it attempts to COW an extent buffer from the extent or device btree for
3407 *    example, it does not find any free extent in any metadata block group,
3408 *    therefore forced to try to allocate a new metadata block group.
3409 *    This is because some other task allocated all available extents in the
3410 *    meanwhile - this typically happens with tasks that don't reserve space
3411 *    properly, either intentionally or as a bug. One example where this is
3412 *    done intentionally is fsync, as it does not reserve any transaction units
3413 *    and ends up allocating a variable number of metadata extents for log
3414 *    tree extent buffers.
3415 *
3416 * We also need this 2 phases setup when adding a device to a filesystem with
3417 * a seed device - we must create new metadata and system chunks without adding
3418 * any of the block group items to the chunk, extent and device btrees. If we
3419 * did not do it this way, we would get ENOSPC when attempting to update those
3420 * btrees, since all the chunks from the seed device are read-only.
3421 *
3422 * Phase 1 does the updates and insertions to the chunk btree because if we had
3423 * it done in phase 2 and have a thundering herd of tasks allocating chunks in
3424 * parallel, we risk having too many system chunks allocated by many tasks if
3425 * many tasks reach phase 1 without the previous ones completing phase 2. In the
3426 * extreme case this leads to exhaustion of the system chunk array in the
3427 * superblock. This is easier to trigger if using a btree node/leaf size of 64K
3428 * and with RAID filesystems (so we have more device items in the chunk btree).
3429 * This has happened before and commit eafa4fd0ad0607 ("btrfs: fix exhaustion of
3430 * the system chunk array due to concurrent allocations") provides more details.
3431 *
3432 * For allocation of system chunks, we defer the updates and insertions into the
3433 * chunk btree to phase 2. This is to prevent deadlocks on extent buffers because
3434 * if the chunk allocation is triggered while COWing an extent buffer of the
3435 * chunk btree, we are holding a lock on the parent of that extent buffer and
3436 * doing the chunk btree updates and insertions can require locking that parent.
3437 * This is for the very few and rare cases where we update the chunk btree that
3438 * are not chunk allocation or chunk removal: adding a device, removing a device
3439 * or resizing a device.
3440 *
3441 * The reservation of system space, done through check_system_chunk(), as well
3442 * as all the updates and insertions into the chunk btree must be done while
3443 * holding fs_info->chunk_mutex. This is important to guarantee that while COWing
3444 * an extent buffer from the chunks btree we never trigger allocation of a new
3445 * system chunk, which would result in a deadlock (trying to lock twice an
3446 * extent buffer of the chunk btree, first time before triggering the chunk
3447 * allocation and the second time during chunk allocation while attempting to
3448 * update the chunks btree). The system chunk array is also updated while holding
3449 * that mutex. The same logic applies to removing chunks - we must reserve system
3450 * space, update the chunk btree and the system chunk array in the superblock
3451 * while holding fs_info->chunk_mutex.
3452 *
3453 * This function, btrfs_chunk_alloc(), belongs to phase 1.
3454 *
3455 * If @force is CHUNK_ALLOC_FORCE:
3456 *    - return 1 if it successfully allocates a chunk,
3457 *    - return errors including -ENOSPC otherwise.
3458 * If @force is NOT CHUNK_ALLOC_FORCE:
3459 *    - return 0 if it doesn't need to allocate a new chunk,
3460 *    - return 1 if it successfully allocates a chunk,
3461 *    - return errors including -ENOSPC otherwise.
3462 */
3463int btrfs_chunk_alloc(struct btrfs_trans_handle *trans, u64 flags,
3464                      enum btrfs_chunk_alloc_enum force)
3465{
3466        struct btrfs_fs_info *fs_info = trans->fs_info;
3467        struct btrfs_space_info *space_info;
3468        bool wait_for_alloc = false;
3469        bool should_alloc = false;
3470        int ret = 0;
3471
3472        /* Don't re-enter if we're already allocating a chunk */
3473        if (trans->allocating_chunk)
3474                return -ENOSPC;
3475        /*
3476         * If we are removing a chunk, don't re-enter or we would deadlock.
3477         * System space reservation and system chunk allocation is done by the
3478         * chunk remove operation (btrfs_remove_chunk()).
3479         */
3480        if (trans->removing_chunk)
3481                return -ENOSPC;
3482
3483        space_info = btrfs_find_space_info(fs_info, flags);
3484        ASSERT(space_info);
3485
3486        do {
3487                spin_lock(&space_info->lock);
3488                if (force < space_info->force_alloc)
3489                        force = space_info->force_alloc;
3490                should_alloc = should_alloc_chunk(fs_info, space_info, force);
3491                if (space_info->full) {
3492                        /* No more free physical space */
3493                        if (should_alloc)
3494                                ret = -ENOSPC;
3495                        else
3496                                ret = 0;
3497                        spin_unlock(&space_info->lock);
3498                        return ret;
3499                } else if (!should_alloc) {
3500                        spin_unlock(&space_info->lock);
3501                        return 0;
3502                } else if (space_info->chunk_alloc) {
3503                        /*
3504                         * Someone is already allocating, so we need to block
3505                         * until this someone is finished and then loop to
3506                         * recheck if we should continue with our allocation
3507                         * attempt.
3508                         */
3509                        wait_for_alloc = true;
3510                        spin_unlock(&space_info->lock);
3511                        mutex_lock(&fs_info->chunk_mutex);
3512                        mutex_unlock(&fs_info->chunk_mutex);
3513                } else {
3514                        /* Proceed with allocation */
3515                        space_info->chunk_alloc = 1;
3516                        wait_for_alloc = false;
3517                        spin_unlock(&space_info->lock);
3518                }
3519
3520                cond_resched();
3521        } while (wait_for_alloc);
3522
3523        mutex_lock(&fs_info->chunk_mutex);
3524        trans->allocating_chunk = true;
3525
3526        /*
3527         * If we have mixed data/metadata chunks we want to make sure we keep
3528         * allocating mixed chunks instead of individual chunks.
3529         */
3530        if (btrfs_mixed_space_info(space_info))
3531                flags |= (BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA);
3532
3533        /*
3534         * if we're doing a data chunk, go ahead and make sure that
3535         * we keep a reasonable number of metadata chunks allocated in the
3536         * FS as well.
3537         */
3538        if (flags & BTRFS_BLOCK_GROUP_DATA && fs_info->metadata_ratio) {
3539                fs_info->data_chunk_allocations++;
3540                if (!(fs_info->data_chunk_allocations %
3541                      fs_info->metadata_ratio))
3542                        force_metadata_allocation(fs_info);
3543        }
3544
3545        ret = do_chunk_alloc(trans, flags);
3546        trans->allocating_chunk = false;
3547
3548        spin_lock(&space_info->lock);
3549        if (ret < 0) {
3550                if (ret == -ENOSPC)
3551                        space_info->full = 1;
3552                else
3553                        goto out;
3554        } else {
3555                ret = 1;
3556                space_info->max_extent_size = 0;
3557        }
3558
3559        space_info->force_alloc = CHUNK_ALLOC_NO_FORCE;
3560out:
3561        space_info->chunk_alloc = 0;
3562        spin_unlock(&space_info->lock);
3563        mutex_unlock(&fs_info->chunk_mutex);
3564
3565        return ret;
3566}
3567
3568static u64 get_profile_num_devs(struct btrfs_fs_info *fs_info, u64 type)
3569{
3570        u64 num_dev;
3571
3572        num_dev = btrfs_raid_array[btrfs_bg_flags_to_raid_index(type)].devs_max;
3573        if (!num_dev)
3574                num_dev = fs_info->fs_devices->rw_devices;
3575
3576        return num_dev;
3577}
3578
3579/*
3580 * Reserve space in the system space for allocating or removing a chunk
3581 */
3582void check_system_chunk(struct btrfs_trans_handle *trans, u64 type)
3583{
3584        struct btrfs_fs_info *fs_info = trans->fs_info;
3585        struct btrfs_space_info *info;
3586        u64 left;
3587        u64 thresh;
3588        int ret = 0;
3589        u64 num_devs;
3590
3591        /*
3592         * Needed because we can end up allocating a system chunk and for an
3593         * atomic and race free space reservation in the chunk block reserve.
3594         */
3595        lockdep_assert_held(&fs_info->chunk_mutex);
3596
3597        info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
3598        spin_lock(&info->lock);
3599        left = info->total_bytes - btrfs_space_info_used(info, true);
3600        spin_unlock(&info->lock);
3601
3602        num_devs = get_profile_num_devs(fs_info, type);
3603
3604        /* num_devs device items to update and 1 chunk item to add or remove */
3605        thresh = btrfs_calc_metadata_size(fs_info, num_devs) +
3606                btrfs_calc_insert_metadata_size(fs_info, 1);
3607
3608        if (left < thresh && btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {
3609                btrfs_info(fs_info, "left=%llu, need=%llu, flags=%llu",
3610                           left, thresh, type);
3611                btrfs_dump_space_info(fs_info, info, 0, 0);
3612        }
3613
3614        if (left < thresh) {
3615                u64 flags = btrfs_system_alloc_profile(fs_info);
3616                struct btrfs_block_group *bg;
3617
3618                /*
3619                 * Ignore failure to create system chunk. We might end up not
3620                 * needing it, as we might not need to COW all nodes/leafs from
3621                 * the paths we visit in the chunk tree (they were already COWed
3622                 * or created in the current transaction for example).
3623                 *
3624                 * Also, if our caller is allocating a system chunk, do not
3625                 * attempt to insert the chunk item in the chunk btree, as we
3626                 * could deadlock on an extent buffer since our caller may be
3627                 * COWing an extent buffer from the chunk btree.
3628                 */
3629                bg = btrfs_alloc_chunk(trans, flags);
3630                if (IS_ERR(bg)) {
3631                        ret = PTR_ERR(bg);
3632                } else if (!(type & BTRFS_BLOCK_GROUP_SYSTEM)) {
3633                        /*
3634                         * If we fail to add the chunk item here, we end up
3635                         * trying again at phase 2 of chunk allocation, at
3636                         * btrfs_create_pending_block_groups(). So ignore
3637                         * any error here.
3638                         */
3639                        btrfs_chunk_alloc_add_chunk_item(trans, bg);
3640                }
3641        }
3642
3643        if (!ret) {
3644                ret = btrfs_block_rsv_add(fs_info->chunk_root,
3645                                          &fs_info->chunk_block_rsv,
3646                                          thresh, BTRFS_RESERVE_NO_FLUSH);
3647                if (!ret)
3648                        trans->chunk_bytes_reserved += thresh;
3649        }
3650}
3651
3652void btrfs_put_block_group_cache(struct btrfs_fs_info *info)
3653{
3654        struct btrfs_block_group *block_group;
3655        u64 last = 0;
3656
3657        while (1) {
3658                struct inode *inode;
3659
3660                block_group = btrfs_lookup_first_block_group(info, last);
3661                while (block_group) {
3662                        btrfs_wait_block_group_cache_done(block_group);
3663                        spin_lock(&block_group->lock);
3664                        if (block_group->iref)
3665                                break;
3666                        spin_unlock(&block_group->lock);
3667                        block_group = btrfs_next_block_group(block_group);
3668                }
3669                if (!block_group) {
3670                        if (last == 0)
3671                                break;
3672                        last = 0;
3673                        continue;
3674                }
3675
3676                inode = block_group->inode;
3677                block_group->iref = 0;
3678                block_group->inode = NULL;
3679                spin_unlock(&block_group->lock);
3680                ASSERT(block_group->io_ctl.inode == NULL);
3681                iput(inode);
3682                last = block_group->start + block_group->length;
3683                btrfs_put_block_group(block_group);
3684        }
3685}
3686
3687/*
3688 * Must be called only after stopping all workers, since we could have block
3689 * group caching kthreads running, and therefore they could race with us if we
3690 * freed the block groups before stopping them.
3691 */
3692int btrfs_free_block_groups(struct btrfs_fs_info *info)
3693{
3694        struct btrfs_block_group *block_group;
3695        struct btrfs_space_info *space_info;
3696        struct btrfs_caching_control *caching_ctl;
3697        struct rb_node *n;
3698
3699        spin_lock(&info->block_group_cache_lock);
3700        while (!list_empty(&info->caching_block_groups)) {
3701                caching_ctl = list_entry(info->caching_block_groups.next,
3702                                         struct btrfs_caching_control, list);
3703                list_del(&caching_ctl->list);
3704                btrfs_put_caching_control(caching_ctl);
3705        }
3706        spin_unlock(&info->block_group_cache_lock);
3707
3708        spin_lock(&info->unused_bgs_lock);
3709        while (!list_empty(&info->unused_bgs)) {
3710                block_group = list_first_entry(&info->unused_bgs,
3711                                               struct btrfs_block_group,
3712                                               bg_list);
3713                list_del_init(&block_group->bg_list);
3714                btrfs_put_block_group(block_group);
3715        }
3716        spin_unlock(&info->unused_bgs_lock);
3717
3718        spin_lock(&info->unused_bgs_lock);
3719        while (!list_empty(&info->reclaim_bgs)) {
3720                block_group = list_first_entry(&info->reclaim_bgs,
3721                                               struct btrfs_block_group,
3722                                               bg_list);
3723                list_del_init(&block_group->bg_list);
3724                btrfs_put_block_group(block_group);
3725        }
3726        spin_unlock(&info->unused_bgs_lock);
3727
3728        spin_lock(&info->block_group_cache_lock);
3729        while ((n = rb_last(&info->block_group_cache_tree)) != NULL) {
3730                block_group = rb_entry(n, struct btrfs_block_group,
3731                                       cache_node);
3732                rb_erase(&block_group->cache_node,
3733                         &info->block_group_cache_tree);
3734                RB_CLEAR_NODE(&block_group->cache_node);
3735                spin_unlock(&info->block_group_cache_lock);
3736
3737                down_write(&block_group->space_info->groups_sem);
3738                list_del(&block_group->list);
3739                up_write(&block_group->space_info->groups_sem);
3740
3741                /*
3742                 * We haven't cached this block group, which means we could
3743                 * possibly have excluded extents on this block group.
3744                 */
3745                if (block_group->cached == BTRFS_CACHE_NO ||
3746                    block_group->cached == BTRFS_CACHE_ERROR)
3747                        btrfs_free_excluded_extents(block_group);
3748
3749                btrfs_remove_free_space_cache(block_group);
3750                ASSERT(block_group->cached != BTRFS_CACHE_STARTED);
3751                ASSERT(list_empty(&block_group->dirty_list));
3752                ASSERT(list_empty(&block_group->io_list));
3753                ASSERT(list_empty(&block_group->bg_list));
3754                ASSERT(refcount_read(&block_group->refs) == 1);
3755                ASSERT(block_group->swap_extents == 0);
3756                btrfs_put_block_group(block_group);
3757
3758                spin_lock(&info->block_group_cache_lock);
3759        }
3760        spin_unlock(&info->block_group_cache_lock);
3761
3762        btrfs_release_global_block_rsv(info);
3763
3764        while (!list_empty(&info->space_info)) {
3765                space_info = list_entry(info->space_info.next,
3766                                        struct btrfs_space_info,
3767                                        list);
3768
3769                /*
3770                 * Do not hide this behind enospc_debug, this is actually
3771                 * important and indicates a real bug if this happens.
3772                 */
3773                if (WARN_ON(space_info->bytes_pinned > 0 ||
3774                            space_info->bytes_reserved > 0 ||
3775                            space_info->bytes_may_use > 0))
3776                        btrfs_dump_space_info(info, space_info, 0, 0);
3777                WARN_ON(space_info->reclaim_size > 0);
3778                list_del(&space_info->list);
3779                btrfs_sysfs_remove_space_info(space_info);
3780        }
3781        return 0;
3782}
3783
3784void btrfs_freeze_block_group(struct btrfs_block_group *cache)
3785{
3786        atomic_inc(&cache->frozen);
3787}
3788
3789void btrfs_unfreeze_block_group(struct btrfs_block_group *block_group)
3790{
3791        struct btrfs_fs_info *fs_info = block_group->fs_info;
3792        struct extent_map_tree *em_tree;
3793        struct extent_map *em;
3794        bool cleanup;
3795
3796        spin_lock(&block_group->lock);
3797        cleanup = (atomic_dec_and_test(&block_group->frozen) &&
3798                   block_group->removed);
3799        spin_unlock(&block_group->lock);
3800
3801        if (cleanup) {
3802                em_tree = &fs_info->mapping_tree;
3803                write_lock(&em_tree->lock);
3804                em = lookup_extent_mapping(em_tree, block_group->start,
3805                                           1);
3806                BUG_ON(!em); /* logic error, can't happen */
3807                remove_extent_mapping(em_tree, em);
3808                write_unlock(&em_tree->lock);
3809
3810                /* once for us and once for the tree */
3811                free_extent_map(em);
3812                free_extent_map(em);
3813
3814                /*
3815                 * We may have left one free space entry and other possible
3816                 * tasks trimming this block group have left 1 entry each one.
3817                 * Free them if any.
3818                 */
3819                __btrfs_remove_free_space_cache(block_group->free_space_ctl);
3820        }
3821}
3822
3823bool btrfs_inc_block_group_swap_extents(struct btrfs_block_group *bg)
3824{
3825        bool ret = true;
3826
3827        spin_lock(&bg->lock);
3828        if (bg->ro)
3829                ret = false;
3830        else
3831                bg->swap_extents++;
3832        spin_unlock(&bg->lock);
3833
3834        return ret;
3835}
3836
3837void btrfs_dec_block_group_swap_extents(struct btrfs_block_group *bg, int amount)
3838{
3839        spin_lock(&bg->lock);
3840        ASSERT(!bg->ro);
3841        ASSERT(bg->swap_extents >= amount);
3842        bg->swap_extents -= amount;
3843        spin_unlock(&bg->lock);
3844}
3845
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.