fs/btrfs/extent-tree.c

   1 /*
   2  * Copyright (C) 2007 Oracle.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 021110-1307, USA.
  17  */
  18 #include <linux/sched.h>
  19 #include <linux/pagemap.h>
  20 #include <linux/writeback.h>
  21 #include <linux/blkdev.h>
  22 #include <linux/sort.h>
  23 #include <linux/rcupdate.h>
  24 #include <linux/kthread.h>
  25 #include <linux/slab.h>
  26 #include <linux/ratelimit.h>
  27 #include "compat.h"
  28 #include "hash.h"
  29 #include "ctree.h"
  30 #include "disk-io.h"
  31 #include "print-tree.h"
  32 #include "transaction.h"
  33 #include "volumes.h"
  34 #include "raid56.h"
  35 #include "locking.h"
  36 #include "free-space-cache.h"
  37 #include "math.h"
  38
  39 #undef SCRAMBLE_DELAYED_REFS
  40
  41 /*
  42  * control flags for do_chunk_alloc's force field
  43  * CHUNK_ALLOC_NO_FORCE means to only allocate a chunk
  44  * if we really need one.
  45  *
  46  * CHUNK_ALLOC_LIMITED means to only try and allocate one
  47  * if we have very few chunks already allocated.  This is
  48  * used as part of the clustering code to help make sure
  49  * we have a good pool of storage to cluster in, without
  50  * filling the FS with empty chunks
  51  *
  52  * CHUNK_ALLOC_FORCE means it must try to allocate one
  53  *
  54  */
  55 enum {
  56         CHUNK_ALLOC_NO_FORCE = 0,
  57         CHUNK_ALLOC_LIMITED = 1,
  58         CHUNK_ALLOC_FORCE = 2,
  59 };
  60
  61 /*
  62  * Control how reservations are dealt with.
  63  *
  64  * RESERVE_FREE - freeing a reservation.
  65  * RESERVE_ALLOC - allocating space and we need to update bytes_may_use for
  66  *   ENOSPC accounting
  67  * RESERVE_ALLOC_NO_ACCOUNT - allocating space and we should not update
  68  *   bytes_may_use as the ENOSPC accounting is done elsewhere
  69  */
  70 enum {
  71         RESERVE_FREE = 0,
  72         RESERVE_ALLOC = 1,
  73         RESERVE_ALLOC_NO_ACCOUNT = 2,
  74 };
  75
  76 static int update_block_group(struct btrfs_root *root,
  77                               u64 bytenr, u64 num_bytes, int alloc);
  78 static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
  79                                 struct btrfs_root *root,
  80                                 u64 bytenr, u64 num_bytes, u64 parent,
  81                                 u64 root_objectid, u64 owner_objectid,
  82                                 u64 owner_offset, int refs_to_drop,
  83                                 struct btrfs_delayed_extent_op *extra_op);
  84 static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
  85                                     struct extent_buffer *leaf,
  86                                     struct btrfs_extent_item *ei);
  87 static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
  88                                       struct btrfs_root *root,
  89                                       u64 parent, u64 root_objectid,
  90                                       u64 flags, u64 owner, u64 offset,
  91                                       struct btrfs_key *ins, int ref_mod);
  92 static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
  93                                      struct btrfs_root *root,
  94                                      u64 parent, u64 root_objectid,
  95                                      u64 flags, struct btrfs_disk_key *key,
  96                                      int level, struct btrfs_key *ins);
  97 static int do_chunk_alloc(struct btrfs_trans_handle *trans,
  98                           struct btrfs_root *extent_root, u64 flags,
  99                           int force);
 100 static int find_next_key(struct btrfs_path *path, int level,
 101                          struct btrfs_key *key);
 102 static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
 103                             int dump_block_groups);
 104 static int btrfs_update_reserved_bytes(struct btrfs_block_group_cache *cache,
 105                                        u64 num_bytes, int reserve);
 106 static int block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv,
 107                                u64 num_bytes);
 108
 109 static noinline int
 110 block_group_cache_done(struct btrfs_block_group_cache *cache)
 111 {
 112         smp_mb();
 113         return cache->cached == BTRFS_CACHE_FINISHED;
 114 }
 115
 116 static int block_group_bits(struct btrfs_block_group_cache *cache, u64 bits)
 117 {
 118         return (cache->flags & bits) == bits;
 119 }
 120
 121 static void btrfs_get_block_group(struct btrfs_block_group_cache *cache)
 122 {
 123         atomic_inc(&cache->count);
 124 }
 125
 126 void btrfs_put_block_group(struct btrfs_block_group_cache *cache)
 127 {
 128         if (atomic_dec_and_test(&cache->count)) {
 129                 WARN_ON(cache->pinned > 0);
 130                 WARN_ON(cache->reserved > 0);
 131                 kfree(cache->free_space_ctl);
 132                 kfree(cache);
 133         }
 134 }
 135
 136 /*
 137  * this adds the block group to the fs_info rb tree for the block group
 138  * cache
 139  */
 140 static int btrfs_add_block_group_cache(struct btrfs_fs_info *info,
 141                                 struct btrfs_block_group_cache *block_group)
 142 {
 143         struct rb_node **p;
 144         struct rb_node *parent = NULL;
 145         struct btrfs_block_group_cache *cache;
 146
 147         spin_lock(&info->block_group_cache_lock);
 148         p = &info->block_group_cache_tree.rb_node;
 149
 150         while (*p) {
 151                 parent = *p;
 152                 cache = rb_entry(parent, struct btrfs_block_group_cache,
 153                                  cache_node);
 154                 if (block_group->key.objectid < cache->key.objectid) {
 155                         p = &(*p)->rb_left;
 156                 } else if (block_group->key.objectid > cache->key.objectid) {
 157                         p = &(*p)->rb_right;
 158                 } else {
 159                         spin_unlock(&info->block_group_cache_lock);
 160                         return -EEXIST;
 161                 }
 162         }
 163
 164         rb_link_node(&block_group->cache_node, parent, p);
 165         rb_insert_color(&block_group->cache_node,
 166                         &info->block_group_cache_tree);
 167
 168         if (info->first_logical_byte > block_group->key.objectid)
 169                 info->first_logical_byte = block_group->key.objectid;
 170
 171         spin_unlock(&info->block_group_cache_lock);
 172
 173         return 0;
 174 }
 175
 176 /*
 177  * This will return the block group at or after bytenr if contains is 0, else
 178  * it will return the block group that contains the bytenr
 179  */
 180 static struct btrfs_block_group_cache *
 181 block_group_cache_tree_search(struct btrfs_fs_info *info, u64 bytenr,
 182                               int contains)
 183 {
 184         struct btrfs_block_group_cache *cache, *ret = NULL;
 185         struct rb_node *n;
 186         u64 end, start;
 187
 188         spin_lock(&info->block_group_cache_lock);
 189         n = info->block_group_cache_tree.rb_node;
 190
 191         while (n) {
 192                 cache = rb_entry(n, struct btrfs_block_group_cache,
 193                                  cache_node);
 194                 end = cache->key.objectid + cache->key.offset - 1;
 195                 start = cache->key.objectid;
 196
 197                 if (bytenr < start) {
 198                         if (!contains && (!ret || start < ret->key.objectid))
 199                                 ret = cache;
 200                         n = n->rb_left;
 201                 } else if (bytenr > start) {
 202                         if (contains && bytenr <= end) {
 203                                 ret = cache;
 204                                 break;
 205                         }
 206                         n = n->rb_right;
 207                 } else {
 208                         ret = cache;
 209                         break;
 210                 }
 211         }
 212         if (ret) {
 213                 btrfs_get_block_group(ret);
 214                 if (bytenr == 0 && info->first_logical_byte > ret->key.objectid)
 215                         info->first_logical_byte = ret->key.objectid;
 216         }
 217         spin_unlock(&info->block_group_cache_lock);
 218
 219         return ret;
 220 }
 221
 222 static int add_excluded_extent(struct btrfs_root *root,
 223                                u64 start, u64 num_bytes)
 224 {
 225         u64 end = start + num_bytes - 1;
 226         set_extent_bits(&root->fs_info->freed_extents[0],
 227                         start, end, EXTENT_UPTODATE, GFP_NOFS);
 228         set_extent_bits(&root->fs_info->freed_extents[1],
 229                         start, end, EXTENT_UPTODATE, GFP_NOFS);
 230         return 0;
 231 }
 232
 233 static void free_excluded_extents(struct btrfs_root *root,
 234                                   struct btrfs_block_group_cache *cache)
 235 {
 236         u64 start, end;
 237
 238         start = cache->key.objectid;
 239         end = start + cache->key.offset - 1;
 240
 241         clear_extent_bits(&root->fs_info->freed_extents[0],
 242                           start, end, EXTENT_UPTODATE, GFP_NOFS);
 243         clear_extent_bits(&root->fs_info->freed_extents[1],
 244                           start, end, EXTENT_UPTODATE, GFP_NOFS);
 245 }
 246
 247 static int exclude_super_stripes(struct btrfs_root *root,
 248                                  struct btrfs_block_group_cache *cache)
 249 {
 250         u64 bytenr;
 251         u64 *logical;
 252         int stripe_len;
 253         int i, nr, ret;
 254
 255         if (cache->key.objectid < BTRFS_SUPER_INFO_OFFSET) {
 256                 stripe_len = BTRFS_SUPER_INFO_OFFSET - cache->key.objectid;
 257                 cache->bytes_super += stripe_len;
 258                 ret = add_excluded_extent(root, cache->key.objectid,
 259                                           stripe_len);
 260                 if (ret)
 261                         return ret;
 262         }
 263
 264         for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
 265                 bytenr = btrfs_sb_offset(i);
 266                 ret = btrfs_rmap_block(&root->fs_info->mapping_tree,
 267                                        cache->key.objectid, bytenr,
 268                                        0, &logical, &nr, &stripe_len);
 269                 if (ret)
 270                         return ret;
 271
 272                 while (nr--) {
 273                         cache->bytes_super += stripe_len;
 274                         ret = add_excluded_extent(root, logical[nr],
 275                                                   stripe_len);
 276                         if (ret) {
 277                                 kfree(logical);
 278                                 return ret;
 279                         }
 280                 }
 281
 282                 kfree(logical);
 283         }
 284         return 0;
 285 }
 286
 287 static struct btrfs_caching_control *
 288 get_caching_control(struct btrfs_block_group_cache *cache)
 289 {
 290         struct btrfs_caching_control *ctl;
 291
 292         spin_lock(&cache->lock);
 293         if (cache->cached != BTRFS_CACHE_STARTED) {
 294                 spin_unlock(&cache->lock);
 295                 return NULL;
 296         }
 297
 298         /* We're loading it the fast way, so we don't have a caching_ctl. */
 299         if (!cache->caching_ctl) {
 300                 spin_unlock(&cache->lock);
 301                 return NULL;
 302         }
 303
 304         ctl = cache->caching_ctl;
 305         atomic_inc(&ctl->count);
 306         spin_unlock(&cache->lock);
 307         return ctl;
 308 }
 309
 310 static void put_caching_control(struct btrfs_caching_control *ctl)
 311 {
 312         if (atomic_dec_and_test(&ctl->count))
 313                 kfree(ctl);
 314 }
 315
 316 /*
 317  * this is only called by cache_block_group, since we could have freed extents
 318  * we need to check the pinned_extents for any extents that can't be used yet
 319  * since their free space will be released as soon as the transaction commits.
 320  */
 321 static u64 add_new_free_space(struct btrfs_block_group_cache *block_group,
 322                               struct btrfs_fs_info *info, u64 start, u64 end)
 323 {
 324         u64 extent_start, extent_end, size, total_added = 0;
 325         int ret;
 326
 327         while (start < end) {
 328                 ret = find_first_extent_bit(info->pinned_extents, start,
 329                                             &extent_start, &extent_end,
 330                                             EXTENT_DIRTY | EXTENT_UPTODATE,
 331                                             NULL);
 332                 if (ret)
 333                         break;
 334
 335                 if (extent_start <= start) {
 336                         start = extent_end + 1;
 337                 } else if (extent_start > start && extent_start < end) {
 338                         size = extent_start - start;
 339                         total_added += size;
 340                         ret = btrfs_add_free_space(block_group, start,
 341                                                    size);
 342                         BUG_ON(ret); /* -ENOMEM or logic error */
 343                         start = extent_end + 1;
 344                 } else {
 345                         break;
 346                 }
 347         }
 348
 349         if (start < end) {
 350                 size = end - start;
 351                 total_added += size;
 352                 ret = btrfs_add_free_space(block_group, start, size);
 353                 BUG_ON(ret); /* -ENOMEM or logic error */
 354         }
 355
 356         return total_added;
 357 }
 358
 359 static noinline void caching_thread(struct btrfs_work *work)
 360 {
 361         struct btrfs_block_group_cache *block_group;
 362         struct btrfs_fs_info *fs_info;
 363         struct btrfs_caching_control *caching_ctl;
 364         struct btrfs_root *extent_root;
 365         struct btrfs_path *path;
 366         struct extent_buffer *leaf;
 367         struct btrfs_key key;
 368         u64 total_found = 0;
 369         u64 last = 0;
 370         u32 nritems;
 371         int ret = 0;
 372
 373         caching_ctl = container_of(work, struct btrfs_caching_control, work);
 374         block_group = caching_ctl->block_group;
 375         fs_info = block_group->fs_info;
 376         extent_root = fs_info->extent_root;
 377
 378         path = btrfs_alloc_path();
 379         if (!path)
 380                 goto out;
 381
 382         last = max_t(u64, block_group->key.objectid, BTRFS_SUPER_INFO_OFFSET);
 383
 384         /*
 385          * We don't want to deadlock with somebody trying to allocate a new
 386          * extent for the extent root while also trying to search the extent
 387          * root to add free space.  So we skip locking and search the commit
 388          * root, since its read-only
 389          */
 390         path->skip_locking = 1;
 391         path->search_commit_root = 1;
 392         path->reada = 1;
 393
 394         key.objectid = last;
 395         key.offset = 0;
 396         key.type = BTRFS_EXTENT_ITEM_KEY;
 397 again:
 398         mutex_lock(&caching_ctl->mutex);
 399         /* need to make sure the commit_root doesn't disappear */
 400         down_read(&fs_info->extent_commit_sem);
 401
 402         ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
 403         if (ret < 0)
 404                 goto err;
 405
 406         leaf = path->nodes[0];
 407         nritems = btrfs_header_nritems(leaf);
 408
 409         while (1) {
 410                 if (btrfs_fs_closing(fs_info) > 1) {
 411                         last = (u64)-1;
 412                         break;
 413                 }
 414
 415                 if (path->slots[0] < nritems) {
 416                         btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 417                 } else {
 418                         ret = find_next_key(path, 0, &key);
 419                         if (ret)
 420                                 break;
 421
 422                         if (need_resched() ||
 423                             btrfs_next_leaf(extent_root, path)) {
 424                                 caching_ctl->progress = last;
 425                                 btrfs_release_path(path);
 426                                 up_read(&fs_info->extent_commit_sem);
 427                                 mutex_unlock(&caching_ctl->mutex);
 428                                 cond_resched();
 429                                 goto again;
 430                         }
 431                         leaf = path->nodes[0];
 432                         nritems = btrfs_header_nritems(leaf);
 433                         continue;
 434                 }
 435
 436                 if (key.objectid < block_group->key.objectid) {
 437                         path->slots[0]++;
 438                         continue;
 439                 }
 440
 441                 if (key.objectid >= block_group->key.objectid +
 442                     block_group->key.offset)
 443                         break;
 444
 445                 if (key.type == BTRFS_EXTENT_ITEM_KEY ||
 446                     key.type == BTRFS_METADATA_ITEM_KEY) {
 447                         total_found += add_new_free_space(block_group,
 448                                                           fs_info, last,
 449                                                           key.objectid);
 450                         if (key.type == BTRFS_METADATA_ITEM_KEY)
 451                                 last = key.objectid +
 452                                         fs_info->tree_root->leafsize;
 453                         else
 454                                 last = key.objectid + key.offset;
 455
 456                         if (total_found > (1024 * 1024 * 2)) {
 457                                 total_found = 0;
 458                                 wake_up(&caching_ctl->wait);
 459                         }
 460                 }
 461                 path->slots[0]++;
 462         }
 463         ret = 0;
 464
 465         total_found += add_new_free_space(block_group, fs_info, last,
 466                                           block_group->key.objectid +
 467                                           block_group->key.offset);
 468         caching_ctl->progress = (u64)-1;
 469
 470         spin_lock(&block_group->lock);
 471         block_group->caching_ctl = NULL;
 472         block_group->cached = BTRFS_CACHE_FINISHED;
 473         spin_unlock(&block_group->lock);
 474
 475 err:
 476         btrfs_free_path(path);
 477         up_read(&fs_info->extent_commit_sem);
 478
 479         free_excluded_extents(extent_root, block_group);
 480
 481         mutex_unlock(&caching_ctl->mutex);
 482 out:
 483         wake_up(&caching_ctl->wait);
 484
 485         put_caching_control(caching_ctl);
 486         btrfs_put_block_group(block_group);
 487 }
 488
 489 static int cache_block_group(struct btrfs_block_group_cache *cache,
 490                              int load_cache_only)
 491 {
 492         DEFINE_WAIT(wait);
 493         struct btrfs_fs_info *fs_info = cache->fs_info;
 494         struct btrfs_caching_control *caching_ctl;
 495         int ret = 0;
 496
 497         caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_NOFS);
 498         if (!caching_ctl)
 499                 return -ENOMEM;
 500
 501         INIT_LIST_HEAD(&caching_ctl->list);
 502         mutex_init(&caching_ctl->mutex);
 503         init_waitqueue_head(&caching_ctl->wait);
 504         caching_ctl->block_group = cache;
 505         caching_ctl->progress = cache->key.objectid;
 506         atomic_set(&caching_ctl->count, 1);
 507         caching_ctl->work.func = caching_thread;
 508
 509         spin_lock(&cache->lock);
 510         /*
 511          * This should be a rare occasion, but this could happen I think in the
 512          * case where one thread starts to load the space cache info, and then
 513          * some other thread starts a transaction commit which tries to do an
 514          * allocation while the other thread is still loading the space cache
 515          * info.  The previous loop should have kept us from choosing this block
 516          * group, but if we've moved to the state where we will wait on caching
 517          * block groups we need to first check if we're doing a fast load here,
 518          * so we can wait for it to finish, otherwise we could end up allocating
 519          * from a block group who's cache gets evicted for one reason or
 520          * another.
 521          */
 522         while (cache->cached == BTRFS_CACHE_FAST) {
 523                 struct btrfs_caching_control *ctl;
 524
 525                 ctl = cache->caching_ctl;
 526                 atomic_inc(&ctl->count);
 527                 prepare_to_wait(&ctl->wait, &wait, TASK_UNINTERRUPTIBLE);
 528                 spin_unlock(&cache->lock);
 529
 530                 schedule();
 531
 532                 finish_wait(&ctl->wait, &wait);
 533                 put_caching_control(ctl);
 534                 spin_lock(&cache->lock);
 535         }
 536
 537         if (cache->cached != BTRFS_CACHE_NO) {
 538                 spin_unlock(&cache->lock);
 539                 kfree(caching_ctl);
 540                 return 0;
 541         }
 542         WARN_ON(cache->caching_ctl);
 543         cache->caching_ctl = caching_ctl;
 544         cache->cached = BTRFS_CACHE_FAST;
 545         spin_unlock(&cache->lock);
 546
 547         if (fs_info->mount_opt & BTRFS_MOUNT_SPACE_CACHE) {
 548                 ret = load_free_space_cache(fs_info, cache);
 549
 550                 spin_lock(&cache->lock);
 551                 if (ret == 1) {
 552                         cache->caching_ctl = NULL;
 553                         cache->cached = BTRFS_CACHE_FINISHED;
 554                         cache->last_byte_to_unpin = (u64)-1;
 555                 } else {
 556                         if (load_cache_only) {
 557                                 cache->caching_ctl = NULL;
 558                                 cache->cached = BTRFS_CACHE_NO;
 559                         } else {
 560                                 cache->cached = BTRFS_CACHE_STARTED;
 561                         }
 562                 }
 563                 spin_unlock(&cache->lock);
 564                 wake_up(&caching_ctl->wait);
 565                 if (ret == 1) {
 566                         put_caching_control(caching_ctl);
 567                         free_excluded_extents(fs_info->extent_root, cache);
 568                         return 0;
 569                 }
 570         } else {
 571                 /*
 572                  * We are not going to do the fast caching, set cached to the
 573                  * appropriate value and wakeup any waiters.
 574                  */
 575                 spin_lock(&cache->lock);
 576                 if (load_cache_only) {
 577                         cache->caching_ctl = NULL;
 578                         cache->cached = BTRFS_CACHE_NO;
 579                 } else {
 580                         cache->cached = BTRFS_CACHE_STARTED;
 581                 }
 582                 spin_unlock(&cache->lock);
 583                 wake_up(&caching_ctl->wait);
 584         }
 585
 586         if (load_cache_only) {
 587                 put_caching_control(caching_ctl);
 588                 return 0;
 589         }
 590
 591         down_write(&fs_info->extent_commit_sem);
 592         atomic_inc(&caching_ctl->count);
 593         list_add_tail(&caching_ctl->list, &fs_info->caching_block_groups);
 594         up_write(&fs_info->extent_commit_sem);
 595
 596         btrfs_get_block_group(cache);
 597
 598         btrfs_queue_worker(&fs_info->caching_workers, &caching_ctl->work);
 599
 600         return ret;
 601 }
 602
 603 /*
 604  * return the block group that starts at or after bytenr
 605  */
 606 static struct btrfs_block_group_cache *
 607 btrfs_lookup_first_block_group(struct btrfs_fs_info *info, u64 bytenr)
 608 {
 609         struct btrfs_block_group_cache *cache;
 610
 611         cache = block_group_cache_tree_search(info, bytenr, 0);
 612
 613         return cache;
 614 }
 615
 616 /*
 617  * return the block group that contains the given bytenr
 618  */
 619 struct btrfs_block_group_cache *btrfs_lookup_block_group(
 620                                                  struct btrfs_fs_info *info,
 621                                                  u64 bytenr)
 622 {
 623         struct btrfs_block_group_cache *cache;
 624
 625         cache = block_group_cache_tree_search(info, bytenr, 1);
 626
 627         return cache;
 628 }
 629
 630 static struct btrfs_space_info *__find_space_info(struct btrfs_fs_info *info,
 631                                                   u64 flags)
 632 {
 633         struct list_head *head = &info->space_info;
 634         struct btrfs_space_info *found;
 635
 636         flags &= BTRFS_BLOCK_GROUP_TYPE_MASK;
 637
 638         rcu_read_lock();
 639         list_for_each_entry_rcu(found, head, list) {
 640                 if (found->flags & flags) {
 641                         rcu_read_unlock();
 642                         return found;
 643                 }
 644         }
 645         rcu_read_unlock();
 646         return NULL;
 647 }
 648
 649 /*
 650  * after adding space to the filesystem, we need to clear the full flags
 651  * on all the space infos.
 652  */
 653 void btrfs_clear_space_info_full(struct btrfs_fs_info *info)
 654 {
 655         struct list_head *head = &info->space_info;
 656         struct btrfs_space_info *found;
 657
 658         rcu_read_lock();
 659         list_for_each_entry_rcu(found, head, list)
 660                 found->full = 0;
 661         rcu_read_unlock();
 662 }
 663
 664 u64 btrfs_find_block_group(struct btrfs_root *root,
 665                            u64 search_start, u64 search_hint, int owner)
 666 {
 667         struct btrfs_block_group_cache *cache;
 668         u64 used;
 669         u64 last = max(search_hint, search_start);
 670         u64 group_start = 0;
 671         int full_search = 0;
 672         int factor = 9;
 673         int wrapped = 0;
 674 again:
 675         while (1) {
 676                 cache = btrfs_lookup_first_block_group(root->fs_info, last);
 677                 if (!cache)
 678                         break;
 679
 680                 spin_lock(&cache->lock);
 681                 last = cache->key.objectid + cache->key.offset;
 682                 used = btrfs_block_group_used(&cache->item);
 683
 684                 if ((full_search || !cache->ro) &&
 685                     block_group_bits(cache, BTRFS_BLOCK_GROUP_METADATA)) {
 686                         if (used + cache->pinned + cache->reserved <
 687                             div_factor(cache->key.offset, factor)) {
 688                                 group_start = cache->key.objectid;
 689                                 spin_unlock(&cache->lock);
 690                                 btrfs_put_block_group(cache);
 691                                 goto found;
 692                         }
 693                 }
 694                 spin_unlock(&cache->lock);
 695                 btrfs_put_block_group(cache);
 696                 cond_resched();
 697         }
 698         if (!wrapped) {
 699                 last = search_start;
 700                 wrapped = 1;
 701                 goto again;
 702         }
 703         if (!full_search && factor < 10) {
 704                 last = search_start;
 705                 full_search = 1;
 706                 factor = 10;
 707                 goto again;
 708         }
 709 found:
 710         return group_start;
 711 }
 712
 713 /* simple helper to search for an existing extent at a given offset */
 714 int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len)
 715 {
 716         int ret;
 717         struct btrfs_key key;
 718         struct btrfs_path *path;
 719
 720         path = btrfs_alloc_path();
 721         if (!path)
 722                 return -ENOMEM;
 723
 724         key.objectid = start;
 725         key.offset = len;
 726         key.type = BTRFS_EXTENT_ITEM_KEY;
 727         ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, path,
 728                                 0, 0);
 729         if (ret > 0) {
 730                 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
 731                 if (key.objectid == start &&
 732                     key.type == BTRFS_METADATA_ITEM_KEY)
 733                         ret = 0;
 734         }
 735         btrfs_free_path(path);
 736         return ret;
 737 }
 738
 739 /*
 740  * helper function to lookup reference count and flags of a tree block.
 741  *
 742  * the head node for delayed ref is used to store the sum of all the
 743  * reference count modifications queued up in the rbtree. the head
 744  * node may also store the extent flags to set. This way you can check
 745  * to see what the reference count and extent flags would be if all of
 746  * the delayed refs are not processed.
 747  */
 748 int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
 749                              struct btrfs_root *root, u64 bytenr,
 750                              u64 offset, int metadata, u64 *refs, u64 *flags)
 751 {
 752         struct btrfs_delayed_ref_head *head;
 753         struct btrfs_delayed_ref_root *delayed_refs;
 754         struct btrfs_path *path;
 755         struct btrfs_extent_item *ei;
 756         struct extent_buffer *leaf;
 757         struct btrfs_key key;
 758         u32 item_size;
 759         u64 num_refs;
 760         u64 extent_flags;
 761         int ret;
 762
 763         /*
 764          * If we don't have skinny metadata, don't bother doing anything
 765          * different
 766          */
 767         if (metadata && !btrfs_fs_incompat(root->fs_info, SKINNY_METADATA)) {
 768                 offset = root->leafsize;
 769                 metadata = 0;
 770         }
 771
 772         path = btrfs_alloc_path();
 773         if (!path)
 774                 return -ENOMEM;
 775
 776         if (metadata) {
 777                 key.objectid = bytenr;
 778                 key.type = BTRFS_METADATA_ITEM_KEY;
 779                 key.offset = offset;
 780         } else {
 781                 key.objectid = bytenr;
 782                 key.type = BTRFS_EXTENT_ITEM_KEY;
 783                 key.offset = offset;
 784         }
 785
 786         if (!trans) {
 787                 path->skip_locking = 1;
 788                 path->search_commit_root = 1;
 789         }
 790 again:
 791         ret = btrfs_search_slot(trans, root->fs_info->extent_root,
 792                                 &key, path, 0, 0);
 793         if (ret < 0)
 794                 goto out_free;
 795
 796         if (ret > 0 && metadata && key.type == BTRFS_METADATA_ITEM_KEY) {
 797                 key.type = BTRFS_EXTENT_ITEM_KEY;
 798                 key.offset = root->leafsize;
 799                 btrfs_release_path(path);
 800                 goto again;
 801         }
 802
 803         if (ret == 0) {
 804                 leaf = path->nodes[0];
 805                 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
 806                 if (item_size >= sizeof(*ei)) {
 807                         ei = btrfs_item_ptr(leaf, path->slots[0],
 808                                             struct btrfs_extent_item);
 809                         num_refs = btrfs_extent_refs(leaf, ei);
 810                         extent_flags = btrfs_extent_flags(leaf, ei);
 811                 } else {
 812 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
 813                         struct btrfs_extent_item_v0 *ei0;
 814                         BUG_ON(item_size != sizeof(*ei0));
 815                         ei0 = btrfs_item_ptr(leaf, path->slots[0],
 816                                              struct btrfs_extent_item_v0);
 817                         num_refs = btrfs_extent_refs_v0(leaf, ei0);
 818                         /* FIXME: this isn't correct for data */
 819                         extent_flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;
 820 #else
 821                         BUG();
 822 #endif
 823                 }
 824                 BUG_ON(num_refs == 0);
 825         } else {
 826                 num_refs = 0;
 827                 extent_flags = 0;
 828                 ret = 0;
 829         }
 830
 831         if (!trans)
 832                 goto out;
 833
 834         delayed_refs = &trans->transaction->delayed_refs;
 835         spin_lock(&delayed_refs->lock);
 836         head = btrfs_find_delayed_ref_head(trans, bytenr);
 837         if (head) {
 838                 if (!mutex_trylock(&head->mutex)) {
 839                         atomic_inc(&head->node.refs);
 840                         spin_unlock(&delayed_refs->lock);
 841
 842                         btrfs_release_path(path);
 843
 844                         /*
 845                          * Mutex was contended, block until it's released and try
 846                          * again
 847                          */
 848                         mutex_lock(&head->mutex);
 849                         mutex_unlock(&head->mutex);
 850                         btrfs_put_delayed_ref(&head->node);
 851                         goto again;
 852                 }
 853                 if (head->extent_op && head->extent_op->update_flags)
 854                         extent_flags |= head->extent_op->flags_to_set;
 855                 else
 856                         BUG_ON(num_refs == 0);
 857
 858                 num_refs += head->node.ref_mod;
 859                 mutex_unlock(&head->mutex);
 860         }
 861         spin_unlock(&delayed_refs->lock);
 862 out:
 863         WARN_ON(num_refs == 0);
 864         if (refs)
 865                 *refs = num_refs;
 866         if (flags)
 867                 *flags = extent_flags;
 868 out_free:
 869         btrfs_free_path(path);
 870         return ret;
 871 }
 872
 873 /*
 874  * Back reference rules.  Back refs have three main goals:
 875  *
 876  * 1) differentiate between all holders of references to an extent so that
 877  *    when a reference is dropped we can make sure it was a valid reference
 878  *    before freeing the extent.
 879  *
 880  * 2) Provide enough information to quickly find the holders of an extent
 881  *    if we notice a given block is corrupted or bad.
 882  *
 883  * 3) Make it easy to migrate blocks for FS shrinking or storage pool
 884  *    maintenance.  This is actually the same as #2, but with a slightly
 885  *    different use case.
 886  *
 887  * There are two kinds of back refs. The implicit back refs is optimized
 888  * for pointers in non-shared tree blocks. For a given pointer in a block,
 889  * back refs of this kind provide information about the block's owner tree
 890  * and the pointer's key. These information allow us to find the block by
 891  * b-tree searching. The full back refs is for pointers in tree blocks not
 892  * referenced by their owner trees. The location of tree block is recorded
 893  * in the back refs. Actually the full back refs is generic, and can be
 894  * used in all cases the implicit back refs is used. The major shortcoming
 895  * of the full back refs is its overhead. Every time a tree block gets
 896  * COWed, we have to update back refs entry for all pointers in it.
 897  *
 898  * For a newly allocated tree block, we use implicit back refs for
 899  * pointers in it. This means most tree related operations only involve
 900  * implicit back refs. For a tree block created in old transaction, the
 901  * only way to drop a reference to it is COW it. So we can detect the
 902  * event that tree block loses its owner tree's reference and do the
 903  * back refs conversion.
 904  *
 905  * When a tree block is COW'd through a tree, there are four cases:
 906  *
 907  * The reference count of the block is one and the tree is the block's
 908  * owner tree. Nothing to do in this case.
 909  *
 910  * The reference count of the block is one and the tree is not the
 911  * block's owner tree. In this case, full back refs is used for pointers
 912  * in the block. Remove these full back refs, add implicit back refs for
 913  * every pointers in the new block.
 914  *
 915  * The reference count of the block is greater than one and the tree is
 916  * the block's owner tree. In this case, implicit back refs is used for
 917  * pointers in the block. Add full back refs for every pointers in the
 918  * block, increase lower level extents' reference counts. The original
 919  * implicit back refs are entailed to the new block.
 920  *
 921  * The reference count of the block is greater than one and the tree is
 922  * not the block's owner tree. Add implicit back refs for every pointer in
 923  * the new block, increase lower level extents' reference count.
 924  *
 925  * Back Reference Key composing:
 926  *
 927  * The key objectid corresponds to the first byte in the extent,
 928  * The key type is used to differentiate between types of back refs.
 929  * There are different meanings of the key offset for different types
 930  * of back refs.
 931  *
 932  * File extents can be referenced by:
 933  *
 934  * - multiple snapshots, subvolumes, or different generations in one subvol
 935  * - different files inside a single subvolume
 936  * - different offsets inside a file (bookend extents in file.c)
 937  *
 938  * The extent ref structure for the implicit back refs has fields for:
 939  *
 940  * - Objectid of the subvolume root
 941  * - objectid of the file holding the reference
 942  * - original offset in the file
 943  * - how many bookend extents
 944  *
 945  * The key offset for the implicit back refs is hash of the first
 946  * three fields.
 947  *
 948  * The extent ref structure for the full back refs has field for:
 949  *
 950  * - number of pointers in the tree leaf
 951  *
 952  * The key offset for the implicit back refs is the first byte of
 953  * the tree leaf
 954  *
 955  * When a file extent is allocated, The implicit back refs is used.
 956  * the fields are filled in:
 957  *
 958  *     (root_key.objectid, inode objectid, offset in file, 1)
 959  *
 960  * When a file extent is removed file truncation, we find the
 961  * corresponding implicit back refs and check the following fields:
 962  *
 963  *     (btrfs_header_owner(leaf), inode objectid, offset in file)
 964  *
 965  * Btree extents can be referenced by:
 966  *
 967  * - Different subvolumes
 968  *
 969  * Both the implicit back refs and the full back refs for tree blocks
 970  * only consist of key. The key offset for the implicit back refs is
 971  * objectid of block's owner tree. The key offset for the full back refs
 972  * is the first byte of parent block.
 973  *
 974  * When implicit back refs is used, information about the lowest key and
 975  * level of the tree block are required. These information are stored in
 976  * tree block info structure.
 977  */
 978
 979 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
 980 static int convert_extent_item_v0(struct btrfs_trans_handle *trans,
 981                                   struct btrfs_root *root,
 982                                   struct btrfs_path *path,
 983                                   u64 owner, u32 extra_size)
 984 {
 985         struct btrfs_extent_item *item;
 986         struct btrfs_extent_item_v0 *ei0;
 987         struct btrfs_extent_ref_v0 *ref0;
 988         struct btrfs_tree_block_info *bi;
 989         struct extent_buffer *leaf;
 990         struct btrfs_key key;
 991         struct btrfs_key found_key;
 992         u32 new_size = sizeof(*item);
 993         u64 refs;
 994         int ret;
 995
 996         leaf = path->nodes[0];
 997         BUG_ON(btrfs_item_size_nr(leaf, path->slots[0]) != sizeof(*ei0));
 998
 999         btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1000         ei0 = btrfs_item_ptr(leaf, path->slots[0],
1001                              struct btrfs_extent_item_v0);
1002         refs = btrfs_extent_refs_v0(leaf, ei0);
1003
1004         if (owner == (u64)-1) {
1005                 while (1) {
1006                         if (path->slots[0] >= btrfs_header_nritems(leaf)) {
1007                                 ret = btrfs_next_leaf(root, path);
1008                                 if (ret < 0)
1009                                         return ret;
1010                                 BUG_ON(ret > 0); /* Corruption */
1011                                 leaf = path->nodes[0];
1012                         }
1013                         btrfs_item_key_to_cpu(leaf, &found_key,
1014                                               path->slots[0]);
1015                         BUG_ON(key.objectid != found_key.objectid);
1016                         if (found_key.type != BTRFS_EXTENT_REF_V0_KEY) {
1017                                 path->slots[0]++;
1018                                 continue;
1019                         }
1020                         ref0 = btrfs_item_ptr(leaf, path->slots[0],
1021                                               struct btrfs_extent_ref_v0);
1022                         owner = btrfs_ref_objectid_v0(leaf, ref0);
1023                         break;
1024                 }
1025         }
1026         btrfs_release_path(path);
1027
1028         if (owner < BTRFS_FIRST_FREE_OBJECTID)
1029                 new_size += sizeof(*bi);
1030
1031         new_size -= sizeof(*ei0);
1032         ret = btrfs_search_slot(trans, root, &key, path,
1033                                 new_size + extra_size, 1);
1034         if (ret < 0)
1035                 return ret;
1036         BUG_ON(ret); /* Corruption */
1037
1038         btrfs_extend_item(trans, root, path, new_size);
1039
1040         leaf = path->nodes[0];
1041         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1042         btrfs_set_extent_refs(leaf, item, refs);
1043         /* FIXME: get real generation */
1044         btrfs_set_extent_generation(leaf, item, 0);
1045         if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1046                 btrfs_set_extent_flags(leaf, item,
1047                                        BTRFS_EXTENT_FLAG_TREE_BLOCK |
1048                                        BTRFS_BLOCK_FLAG_FULL_BACKREF);
1049                 bi = (struct btrfs_tree_block_info *)(item + 1);
1050                 /* FIXME: get first key of the block */
1051                 memset_extent_buffer(leaf, 0, (unsigned long)bi, sizeof(*bi));
1052                 btrfs_set_tree_block_level(leaf, bi, (int)owner);
1053         } else {
1054                 btrfs_set_extent_flags(leaf, item, BTRFS_EXTENT_FLAG_DATA);
1055         }
1056         btrfs_mark_buffer_dirty(leaf);
1057         return 0;
1058 }
1059 #endif
1060
1061 static u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset)
1062 {
1063         u32 high_crc = ~(u32)0;
1064         u32 low_crc = ~(u32)0;
1065         __le64 lenum;
1066
1067         lenum = cpu_to_le64(root_objectid);
1068         high_crc = crc32c(high_crc, &lenum, sizeof(lenum));
1069         lenum = cpu_to_le64(owner);
1070         low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
1071         lenum = cpu_to_le64(offset);
1072         low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
1073
1074         return ((u64)high_crc << 31) ^ (u64)low_crc;
1075 }
1076
1077 static u64 hash_extent_data_ref_item(struct extent_buffer *leaf,
1078                                      struct btrfs_extent_data_ref *ref)
1079 {
1080         return hash_extent_data_ref(btrfs_extent_data_ref_root(leaf, ref),
1081                                     btrfs_extent_data_ref_objectid(leaf, ref),
1082                                     btrfs_extent_data_ref_offset(leaf, ref));
1083 }
1084
1085 static int match_extent_data_ref(struct extent_buffer *leaf,
1086                                  struct btrfs_extent_data_ref *ref,
1087                                  u64 root_objectid, u64 owner, u64 offset)
1088 {
1089         if (btrfs_extent_data_ref_root(leaf, ref) != root_objectid ||
1090             btrfs_extent_data_ref_objectid(leaf, ref) != owner ||
1091             btrfs_extent_data_ref_offset(leaf, ref) != offset)
1092                 return 0;
1093         return 1;
1094 }
1095
1096 static noinline int lookup_extent_data_ref(struct btrfs_trans_handle *trans,
1097                                            struct btrfs_root *root,
1098                                            struct btrfs_path *path,
1099                                            u64 bytenr, u64 parent,
1100                                            u64 root_objectid,
1101                                            u64 owner, u64 offset)
1102 {
1103         struct btrfs_key key;
1104         struct btrfs_extent_data_ref *ref;
1105         struct extent_buffer *leaf;
1106         u32 nritems;
1107         int ret;
1108         int recow;
1109         int err = -ENOENT;
1110
1111         key.objectid = bytenr;
1112         if (parent) {
1113                 key.type = BTRFS_SHARED_DATA_REF_KEY;
1114                 key.offset = parent;
1115         } else {
1116                 key.type = BTRFS_EXTENT_DATA_REF_KEY;
1117                 key.offset = hash_extent_data_ref(root_objectid,
1118                                                   owner, offset);
1119         }
1120 again:
1121         recow = 0;
1122         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1123         if (ret < 0) {
1124                 err = ret;
1125                 goto fail;
1126         }
1127
1128         if (parent) {
1129                 if (!ret)
1130                         return 0;
1131 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1132                 key.type = BTRFS_EXTENT_REF_V0_KEY;
1133                 btrfs_release_path(path);
1134                 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1135                 if (ret < 0) {
1136                         err = ret;
1137                         goto fail;
1138                 }
1139                 if (!ret)
1140                         return 0;
1141 #endif
1142                 goto fail;
1143         }
1144
1145         leaf = path->nodes[0];
1146         nritems = btrfs_header_nritems(leaf);
1147         while (1) {
1148                 if (path->slots[0] >= nritems) {
1149                         ret = btrfs_next_leaf(root, path);
1150                         if (ret < 0)
1151                                 err = ret;
1152                         if (ret)
1153                                 goto fail;
1154
1155                         leaf = path->nodes[0];
1156                         nritems = btrfs_header_nritems(leaf);
1157                         recow = 1;
1158                 }
1159
1160                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1161                 if (key.objectid != bytenr ||
1162                     key.type != BTRFS_EXTENT_DATA_REF_KEY)
1163                         goto fail;
1164
1165                 ref = btrfs_item_ptr(leaf, path->slots[0],
1166                                      struct btrfs_extent_data_ref);
1167
1168                 if (match_extent_data_ref(leaf, ref, root_objectid,
1169                                           owner, offset)) {
1170                         if (recow) {
1171                                 btrfs_release_path(path);
1172                                 goto again;
1173                         }
1174                         err = 0;
1175                         break;
1176                 }
1177                 path->slots[0]++;
1178         }
1179 fail:
1180         return err;
1181 }
1182
1183 static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans,
1184                                            struct btrfs_root *root,
1185                                            struct btrfs_path *path,
1186                                            u64 bytenr, u64 parent,
1187                                            u64 root_objectid, u64 owner,
1188                                            u64 offset, int refs_to_add)
1189 {
1190         struct btrfs_key key;
1191         struct extent_buffer *leaf;
1192         u32 size;
1193         u32 num_refs;
1194         int ret;
1195
1196         key.objectid = bytenr;
1197         if (parent) {
1198                 key.type = BTRFS_SHARED_DATA_REF_KEY;
1199                 key.offset = parent;
1200                 size = sizeof(struct btrfs_shared_data_ref);
1201         } else {
1202                 key.type = BTRFS_EXTENT_DATA_REF_KEY;
1203                 key.offset = hash_extent_data_ref(root_objectid,
1204                                                   owner, offset);
1205                 size = sizeof(struct btrfs_extent_data_ref);
1206         }
1207
1208         ret = btrfs_insert_empty_item(trans, root, path, &key, size);
1209         if (ret && ret != -EEXIST)
1210                 goto fail;
1211
1212         leaf = path->nodes[0];
1213         if (parent) {
1214                 struct btrfs_shared_data_ref *ref;
1215                 ref = btrfs_item_ptr(leaf, path->slots[0],
1216                                      struct btrfs_shared_data_ref);
1217                 if (ret == 0) {
1218                         btrfs_set_shared_data_ref_count(leaf, ref, refs_to_add);
1219                 } else {
1220                         num_refs = btrfs_shared_data_ref_count(leaf, ref);
1221                         num_refs += refs_to_add;
1222                         btrfs_set_shared_data_ref_count(leaf, ref, num_refs);
1223                 }
1224         } else {
1225                 struct btrfs_extent_data_ref *ref;
1226                 while (ret == -EEXIST) {
1227                         ref = btrfs_item_ptr(leaf, path->slots[0],
1228                                              struct btrfs_extent_data_ref);
1229                         if (match_extent_data_ref(leaf, ref, root_objectid,
1230                                                   owner, offset))
1231                                 break;
1232                         btrfs_release_path(path);
1233                         key.offset++;
1234                         ret = btrfs_insert_empty_item(trans, root, path, &key,
1235                                                       size);
1236                         if (ret && ret != -EEXIST)
1237                                 goto fail;
1238
1239                         leaf = path->nodes[0];
1240                 }
1241                 ref = btrfs_item_ptr(leaf, path->slots[0],
1242                                      struct btrfs_extent_data_ref);
1243                 if (ret == 0) {
1244                         btrfs_set_extent_data_ref_root(leaf, ref,
1245                                                        root_objectid);
1246                         btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
1247                         btrfs_set_extent_data_ref_offset(leaf, ref, offset);
1248                         btrfs_set_extent_data_ref_count(leaf, ref, refs_to_add);
1249                 } else {
1250                         num_refs = btrfs_extent_data_ref_count(leaf, ref);
1251                         num_refs += refs_to_add;
1252                         btrfs_set_extent_data_ref_count(leaf, ref, num_refs);
1253                 }
1254         }
1255         btrfs_mark_buffer_dirty(leaf);
1256         ret = 0;
1257 fail:
1258         btrfs_release_path(path);
1259         return ret;
1260 }
1261
1262 static noinline int remove_extent_data_ref(struct btrfs_trans_handle *trans,
1263                                            struct btrfs_root *root,
1264                                            struct btrfs_path *path,
1265                                            int refs_to_drop)
1266 {
1267         struct btrfs_key key;
1268         struct btrfs_extent_data_ref *ref1 = NULL;
1269         struct btrfs_shared_data_ref *ref2 = NULL;
1270         struct extent_buffer *leaf;
1271         u32 num_refs = 0;
1272         int ret = 0;
1273
1274         leaf = path->nodes[0];
1275         btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1276
1277         if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
1278                 ref1 = btrfs_item_ptr(leaf, path->slots[0],
1279                                       struct btrfs_extent_data_ref);
1280                 num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1281         } else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
1282                 ref2 = btrfs_item_ptr(leaf, path->slots[0],
1283                                       struct btrfs_shared_data_ref);
1284                 num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1285 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1286         } else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
1287                 struct btrfs_extent_ref_v0 *ref0;
1288                 ref0 = btrfs_item_ptr(leaf, path->slots[0],
1289                                       struct btrfs_extent_ref_v0);
1290                 num_refs = btrfs_ref_count_v0(leaf, ref0);
1291 #endif
1292         } else {
1293                 BUG();
1294         }
1295
1296         BUG_ON(num_refs < refs_to_drop);
1297         num_refs -= refs_to_drop;
1298
1299         if (num_refs == 0) {
1300                 ret = btrfs_del_item(trans, root, path);
1301         } else {
1302                 if (key.type == BTRFS_EXTENT_DATA_REF_KEY)
1303                         btrfs_set_extent_data_ref_count(leaf, ref1, num_refs);
1304                 else if (key.type == BTRFS_SHARED_DATA_REF_KEY)
1305                         btrfs_set_shared_data_ref_count(leaf, ref2, num_refs);
1306 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1307                 else {
1308                         struct btrfs_extent_ref_v0 *ref0;
1309                         ref0 = btrfs_item_ptr(leaf, path->slots[0],
1310                                         struct btrfs_extent_ref_v0);
1311                         btrfs_set_ref_count_v0(leaf, ref0, num_refs);
1312                 }
1313 #endif
1314                 btrfs_mark_buffer_dirty(leaf);
1315         }
1316         return ret;
1317 }
1318
1319 static noinline u32 extent_data_ref_count(struct btrfs_root *root,
1320                                           struct btrfs_path *path,
1321                                           struct btrfs_extent_inline_ref *iref)
1322 {
1323         struct btrfs_key key;
1324         struct extent_buffer *leaf;
1325         struct btrfs_extent_data_ref *ref1;
1326         struct btrfs_shared_data_ref *ref2;
1327         u32 num_refs = 0;
1328
1329         leaf = path->nodes[0];
1330         btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1331         if (iref) {
1332                 if (btrfs_extent_inline_ref_type(leaf, iref) ==
1333                     BTRFS_EXTENT_DATA_REF_KEY) {
1334                         ref1 = (struct btrfs_extent_data_ref *)(&iref->offset);
1335                         num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1336                 } else {
1337                         ref2 = (struct btrfs_shared_data_ref *)(iref + 1);
1338                         num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1339                 }
1340         } else if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
1341                 ref1 = btrfs_item_ptr(leaf, path->slots[0],
1342                                       struct btrfs_extent_data_ref);
1343                 num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1344         } else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
1345                 ref2 = btrfs_item_ptr(leaf, path->slots[0],
1346                                       struct btrfs_shared_data_ref);
1347                 num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1348 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1349         } else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
1350                 struct btrfs_extent_ref_v0 *ref0;
1351                 ref0 = btrfs_item_ptr(leaf, path->slots[0],
1352                                       struct btrfs_extent_ref_v0);
1353                 num_refs = btrfs_ref_count_v0(leaf, ref0);
1354 #endif
1355         } else {
1356                 WARN_ON(1);
1357         }
1358         return num_refs;
1359 }
1360
1361 static noinline int lookup_tree_block_ref(struct btrfs_trans_handle *trans,
1362                                           struct btrfs_root *root,
1363                                           struct btrfs_path *path,
1364                                           u64 bytenr, u64 parent,
1365                                           u64 root_objectid)
1366 {
1367         struct btrfs_key key;
1368         int ret;
1369
1370         key.objectid = bytenr;
1371         if (parent) {
1372                 key.type = BTRFS_SHARED_BLOCK_REF_KEY;
1373                 key.offset = parent;
1374         } else {
1375                 key.type = BTRFS_TREE_BLOCK_REF_KEY;
1376                 key.offset = root_objectid;
1377         }
1378
1379         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1380         if (ret > 0)
1381                 ret = -ENOENT;
1382 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1383         if (ret == -ENOENT && parent) {
1384                 btrfs_release_path(path);
1385                 key.type = BTRFS_EXTENT_REF_V0_KEY;
1386                 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1387                 if (ret > 0)
1388                         ret = -ENOENT;
1389         }
1390 #endif
1391         return ret;
1392 }
1393
1394 static noinline int insert_tree_block_ref(struct btrfs_trans_handle *trans,
1395                                           struct btrfs_root *root,
1396                                           struct btrfs_path *path,
1397                                           u64 bytenr, u64 parent,
1398                                           u64 root_objectid)
1399 {
1400         struct btrfs_key key;
1401         int ret;
1402
1403         key.objectid = bytenr;
1404         if (parent) {
1405                 key.type = BTRFS_SHARED_BLOCK_REF_KEY;
1406                 key.offset = parent;
1407         } else {
1408                 key.type = BTRFS_TREE_BLOCK_REF_KEY;
1409                 key.offset = root_objectid;
1410         }
1411
1412         ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
1413         btrfs_release_path(path);
1414         return ret;
1415 }
1416
1417 static inline int extent_ref_type(u64 parent, u64 owner)
1418 {
1419         int type;
1420         if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1421                 if (parent > 0)
1422                         type = BTRFS_SHARED_BLOCK_REF_KEY;
1423                 else
1424                         type = BTRFS_TREE_BLOCK_REF_KEY;
1425         } else {
1426                 if (parent > 0)
1427                         type = BTRFS_SHARED_DATA_REF_KEY;
1428                 else
1429                         type = BTRFS_EXTENT_DATA_REF_KEY;
1430         }
1431         return type;
1432 }
1433
1434 static int find_next_key(struct btrfs_path *path, int level,
1435                          struct btrfs_key *key)
1436
1437 {
1438         for (; level < BTRFS_MAX_LEVEL; level++) {
1439                 if (!path->nodes[level])
1440                         break;
1441                 if (path->slots[level] + 1 >=
1442                     btrfs_header_nritems(path->nodes[level]))
1443                         continue;
1444                 if (level == 0)
1445                         btrfs_item_key_to_cpu(path->nodes[level], key,
1446                                               path->slots[level] + 1);
1447                 else
1448                         btrfs_node_key_to_cpu(path->nodes[level], key,
1449                                               path->slots[level] + 1);
1450                 return 0;
1451         }
1452         return 1;
1453 }
1454
1455 /*
1456  * look for inline back ref. if back ref is found, *ref_ret is set
1457  * to the address of inline back ref, and 0 is returned.
1458  *
1459  * if back ref isn't found, *ref_ret is set to the address where it
1460  * should be inserted, and -ENOENT is returned.
1461  *
1462  * if insert is true and there are too many inline back refs, the path
1463  * points to the extent item, and -EAGAIN is returned.
1464  *
1465  * NOTE: inline back refs are ordered in the same way that back ref
1466  *       items in the tree are ordered.
1467  */
1468 static noinline_for_stack
1469 int lookup_inline_extent_backref(struct btrfs_trans_handle *trans,
1470                                  struct btrfs_root *root,
1471                                  struct btrfs_path *path,
1472                                  struct btrfs_extent_inline_ref **ref_ret,
1473                                  u64 bytenr, u64 num_bytes,
1474                                  u64 parent, u64 root_objectid,
1475                                  u64 owner, u64 offset, int insert)
1476 {
1477         struct btrfs_key key;
1478         struct extent_buffer *leaf;
1479         struct btrfs_extent_item *ei;
1480         struct btrfs_extent_inline_ref *iref;
1481         u64 flags;
1482         u64 item_size;
1483         unsigned long ptr;
1484         unsigned long end;
1485         int extra_size;
1486         int type;
1487         int want;
1488         int ret;
1489         int err = 0;
1490         bool skinny_metadata = btrfs_fs_incompat(root->fs_info,
1491                                                  SKINNY_METADATA);
1492
1493         key.objectid = bytenr;
1494         key.type = BTRFS_EXTENT_ITEM_KEY;
1495         key.offset = num_bytes;
1496
1497         want = extent_ref_type(parent, owner);
1498         if (insert) {
1499                 extra_size = btrfs_extent_inline_ref_size(want);
1500                 path->keep_locks = 1;
1501         } else
1502                 extra_size = -1;
1503
1504         /*
1505          * Owner is our parent level, so we can just add one to get the level
1506          * for the block we are interested in.
1507          */
1508         if (skinny_metadata && owner < BTRFS_FIRST_FREE_OBJECTID) {
1509                 key.type = BTRFS_METADATA_ITEM_KEY;
1510                 key.offset = owner;
1511         }
1512
1513 again:
1514         ret = btrfs_search_slot(trans, root, &key, path, extra_size, 1);
1515         if (ret < 0) {
1516                 err = ret;
1517                 goto out;
1518         }
1519
1520         /*
1521          * We may be a newly converted file system which still has the old fat
1522          * extent entries for metadata, so try and see if we have one of those.
1523          */
1524         if (ret > 0 && skinny_metadata) {
1525                 skinny_metadata = false;
1526                 if (path->slots[0]) {
1527                         path->slots[0]--;
1528                         btrfs_item_key_to_cpu(path->nodes[0], &key,
1529                                               path->slots[0]);
1530                         if (key.objectid == bytenr &&
1531                             key.type == BTRFS_EXTENT_ITEM_KEY &&
1532                             key.offset == num_bytes)
1533                                 ret = 0;
1534                 }
1535                 if (ret) {
1536                         key.type = BTRFS_EXTENT_ITEM_KEY;
1537                         key.offset = num_bytes;
1538                         btrfs_release_path(path);
1539                         goto again;
1540                 }
1541         }
1542
1543         if (ret && !insert) {
1544                 err = -ENOENT;
1545                 goto out;
1546         } else if (ret) {
1547                 err = -EIO;
1548                 WARN_ON(1);
1549                 goto out;
1550         }
1551
1552         leaf = path->nodes[0];
1553         item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1554 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1555         if (item_size < sizeof(*ei)) {
1556                 if (!insert) {
1557                         err = -ENOENT;
1558                         goto out;
1559                 }
1560                 ret = convert_extent_item_v0(trans, root, path, owner,
1561                                              extra_size);
1562                 if (ret < 0) {
1563                         err = ret;
1564                         goto out;
1565                 }
1566                 leaf = path->nodes[0];
1567                 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1568         }
1569 #endif
1570         BUG_ON(item_size < sizeof(*ei));
1571
1572         ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1573         flags = btrfs_extent_flags(leaf, ei);
1574
1575         ptr = (unsigned long)(ei + 1);
1576         end = (unsigned long)ei + item_size;
1577
1578         if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK && !skinny_metadata) {
1579                 ptr += sizeof(struct btrfs_tree_block_info);
1580                 BUG_ON(ptr > end);
1581         }
1582
1583         err = -ENOENT;
1584         while (1) {
1585                 if (ptr >= end) {
1586                         WARN_ON(ptr > end);
1587                         break;
1588                 }
1589                 iref = (struct btrfs_extent_inline_ref *)ptr;
1590                 type = btrfs_extent_inline_ref_type(leaf, iref);
1591                 if (want < type)
1592                         break;
1593                 if (want > type) {
1594                         ptr += btrfs_extent_inline_ref_size(type);
1595                         continue;
1596                 }
1597
1598                 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1599                         struct btrfs_extent_data_ref *dref;
1600                         dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1601                         if (match_extent_data_ref(leaf, dref, root_objectid,
1602                                                   owner, offset)) {
1603                                 err = 0;
1604                                 break;
1605                         }
1606                         if (hash_extent_data_ref_item(leaf, dref) <
1607                             hash_extent_data_ref(root_objectid, owner, offset))
1608                                 break;
1609                 } else {
1610                         u64 ref_offset;
1611                         ref_offset = btrfs_extent_inline_ref_offset(leaf, iref);
1612                         if (parent > 0) {
1613                                 if (parent == ref_offset) {
1614                                         err = 0;
1615                                         break;
1616                                 }
1617                                 if (ref_offset < parent)
1618                                         break;
1619                         } else {
1620                                 if (root_objectid == ref_offset) {
1621                                         err = 0;
1622                                         break;
1623                                 }
1624                                 if (ref_offset < root_objectid)
1625                                         break;
1626                         }
1627                 }
1628                 ptr += btrfs_extent_inline_ref_size(type);
1629         }
1630         if (err == -ENOENT && insert) {
1631                 if (item_size + extra_size >=
1632                     BTRFS_MAX_EXTENT_ITEM_SIZE(root)) {
1633                         err = -EAGAIN;
1634                         goto out;
1635                 }
1636                 /*
1637                  * To add new inline back ref, we have to make sure
1638                  * there is no corresponding back ref item.
1639                  * For simplicity, we just do not add new inline back
1640                  * ref if there is any kind of item for this block
1641                  */
1642                 if (find_next_key(path, 0, &key) == 0 &&
1643                     key.objectid == bytenr &&
1644                     key.type < BTRFS_BLOCK_GROUP_ITEM_KEY) {
1645                         err = -EAGAIN;
1646                         goto out;
1647                 }
1648         }
1649         *ref_ret = (struct btrfs_extent_inline_ref *)ptr;
1650 out:
1651         if (insert) {
1652                 path->keep_locks = 0;
1653                 btrfs_unlock_up_safe(path, 1);
1654         }
1655         return err;
1656 }
1657
1658 /*
1659  * helper to add new inline back ref
1660  */
1661 static noinline_for_stack
1662 void setup_inline_extent_backref(struct btrfs_trans_handle *trans,
1663                                  struct btrfs_root *root,
1664                                  struct btrfs_path *path,
1665                                  struct btrfs_extent_inline_ref *iref,
1666                                  u64 parent, u64 root_objectid,
1667                                  u64 owner, u64 offset, int refs_to_add,
1668                                  struct btrfs_delayed_extent_op *extent_op)
1669 {
1670         struct extent_buffer *leaf;
1671         struct btrfs_extent_item *ei;
1672         unsigned long ptr;
1673         unsigned long end;
1674         unsigned long item_offset;
1675         u64 refs;
1676         int size;
1677         int type;
1678
1679         leaf = path->nodes[0];
1680         ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1681         item_offset = (unsigned long)iref - (unsigned long)ei;
1682
1683         type = extent_ref_type(parent, owner);
1684         size = btrfs_extent_inline_ref_size(type);
1685
1686         btrfs_extend_item(trans, root, path, size);
1687
1688         ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1689         refs = btrfs_extent_refs(leaf, ei);
1690         refs += refs_to_add;
1691         btrfs_set_extent_refs(leaf, ei, refs);
1692         if (extent_op)
1693                 __run_delayed_extent_op(extent_op, leaf, ei);
1694
1695         ptr = (unsigned long)ei + item_offset;
1696         end = (unsigned long)ei + btrfs_item_size_nr(leaf, path->slots[0]);
1697         if (ptr < end - size)
1698                 memmove_extent_buffer(leaf, ptr + size, ptr,
1699                                       end - size - ptr);
1700
1701         iref = (struct btrfs_extent_inline_ref *)ptr;
1702         btrfs_set_extent_inline_ref_type(leaf, iref, type);
1703         if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1704                 struct btrfs_extent_data_ref *dref;
1705                 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1706                 btrfs_set_extent_data_ref_root(leaf, dref, root_objectid);
1707                 btrfs_set_extent_data_ref_objectid(leaf, dref, owner);
1708                 btrfs_set_extent_data_ref_offset(leaf, dref, offset);
1709                 btrfs_set_extent_data_ref_count(leaf, dref, refs_to_add);
1710         } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
1711                 struct btrfs_shared_data_ref *sref;
1712                 sref = (struct btrfs_shared_data_ref *)(iref + 1);
1713                 btrfs_set_shared_data_ref_count(leaf, sref, refs_to_add);
1714                 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
1715         } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
1716                 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
1717         } else {
1718                 btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
1719         }
1720         btrfs_mark_buffer_dirty(leaf);
1721 }
1722
1723 static int lookup_extent_backref(struct btrfs_trans_handle *trans,
1724                                  struct btrfs_root *root,
1725                                  struct btrfs_path *path,
1726                                  struct btrfs_extent_inline_ref **ref_ret,
1727                                  u64 bytenr, u64 num_bytes, u64 parent,
1728                                  u64 root_objectid, u64 owner, u64 offset)
1729 {
1730         int ret;
1731
1732         ret = lookup_inline_extent_backref(trans, root, path, ref_ret,
1733                                            bytenr, num_bytes, parent,
1734                                            root_objectid, owner, offset, 0);
1735         if (ret != -ENOENT)
1736                 return ret;
1737
1738         btrfs_release_path(path);
1739         *ref_ret = NULL;
1740
1741         if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1742                 ret = lookup_tree_block_ref(trans, root, path, bytenr, parent,
1743                                             root_objectid);
1744         } else {
1745                 ret = lookup_extent_data_ref(trans, root, path, bytenr, parent,
1746                                              root_objectid, owner, offset);
1747         }
1748         return ret;
1749 }
1750
1751 /*
1752  * helper to update/remove inline back ref
1753  */
1754 static noinline_for_stack
1755 void update_inline_extent_backref(struct btrfs_trans_handle *trans,
1756                                   struct btrfs_root *root,
1757                                   struct btrfs_path *path,
1758                                   struct btrfs_extent_inline_ref *iref,
1759                                   int refs_to_mod,
1760                                   struct btrfs_delayed_extent_op *extent_op)
1761 {
1762         struct extent_buffer *leaf;
1763         struct btrfs_extent_item *ei;
1764         struct btrfs_extent_data_ref *dref = NULL;
1765         struct btrfs_shared_data_ref *sref = NULL;
1766         unsigned long ptr;
1767         unsigned long end;
1768         u32 item_size;
1769         int size;
1770         int type;
1771         u64 refs;
1772
1773         leaf = path->nodes[0];
1774         ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1775         refs = btrfs_extent_refs(leaf, ei);
1776         WARN_ON(refs_to_mod < 0 && refs + refs_to_mod <= 0);
1777         refs += refs_to_mod;
1778         btrfs_set_extent_refs(leaf, ei, refs);
1779         if (extent_op)
1780                 __run_delayed_extent_op(extent_op, leaf, ei);
1781
1782         type = btrfs_extent_inline_ref_type(leaf, iref);
1783
1784         if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1785                 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1786                 refs = btrfs_extent_data_ref_count(leaf, dref);
1787         } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
1788                 sref = (struct btrfs_shared_data_ref *)(iref + 1);
1789                 refs = btrfs_shared_data_ref_count(leaf, sref);
1790         } else {
1791                 refs = 1;
1792                 BUG_ON(refs_to_mod != -1);
1793         }
1794
1795         BUG_ON(refs_to_mod < 0 && refs < -refs_to_mod);
1796         refs += refs_to_mod;
1797
1798         if (refs > 0) {
1799                 if (type == BTRFS_EXTENT_DATA_REF_KEY)
1800                         btrfs_set_extent_data_ref_count(leaf, dref, refs);
1801                 else
1802                         btrfs_set_shared_data_ref_count(leaf, sref, refs);
1803         } else {
1804                 size =  btrfs_extent_inline_ref_size(type);
1805                 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1806                 ptr = (unsigned long)iref;
1807                 end = (unsigned long)ei + item_size;
1808                 if (ptr + size < end)
1809                         memmove_extent_buffer(leaf, ptr, ptr + size,
1810                                               end - ptr - size);
1811                 item_size -= size;
1812                 btrfs_truncate_item(trans, root, path, item_size, 1);
1813         }
1814         btrfs_mark_buffer_dirty(leaf);
1815 }
1816
1817 static noinline_for_stack
1818 int insert_inline_extent_backref(struct btrfs_trans_handle *trans,
1819                                  struct btrfs_root *root,
1820                                  struct btrfs_path *path,
1821                                  u64 bytenr, u64 num_bytes, u64 parent,
1822                                  u64 root_objectid, u64 owner,
1823                                  u64 offset, int refs_to_add,
1824                                  struct btrfs_delayed_extent_op *extent_op)
1825 {
1826         struct btrfs_extent_inline_ref *iref;
1827         int ret;
1828
1829         ret = lookup_inline_extent_backref(trans, root, path, &iref,
1830                                            bytenr, num_bytes, parent,
1831                                            root_objectid, owner, offset, 1);
1832         if (ret == 0) {
1833                 BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID);
1834                 update_inline_extent_backref(trans, root, path, iref,
1835                                              refs_to_add, extent_op);
1836         } else if (ret == -ENOENT) {
1837                 setup_inline_extent_backref(trans, root, path, iref, parent,
1838                                             root_objectid, owner, offset,
1839                                             refs_to_add, extent_op);
1840                 ret = 0;
1841         }
1842         return ret;
1843 }
1844
1845 static int insert_extent_backref(struct btrfs_trans_handle *trans,
1846                                  struct btrfs_root *root,
1847                                  struct btrfs_path *path,
1848                                  u64 bytenr, u64 parent, u64 root_objectid,
1849                                  u64 owner, u64 offset, int refs_to_add)
1850 {
1851         int ret;
1852         if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1853                 BUG_ON(refs_to_add != 1);
1854                 ret = insert_tree_block_ref(trans, root, path, bytenr,
1855                                             parent, root_objectid);
1856         } else {
1857                 ret = insert_extent_data_ref(trans, root, path, bytenr,
1858                                              parent, root_objectid,
1859                                              owner, offset, refs_to_add);
1860         }
1861         return ret;
1862 }
1863
1864 static int remove_extent_backref(struct btrfs_trans_handle *trans,
1865                                  struct btrfs_root *root,
1866                                  struct btrfs_path *path,
1867                                  struct btrfs_extent_inline_ref *iref,
1868                                  int refs_to_drop, int is_data)
1869 {
1870         int ret = 0;
1871
1872         BUG_ON(!is_data && refs_to_drop != 1);
1873         if (iref) {
1874                 update_inline_extent_backref(trans, root, path, iref,
1875                                              -refs_to_drop, NULL);
1876         } else if (is_data) {
1877                 ret = remove_extent_data_ref(trans, root, path, refs_to_drop);
1878         } else {
1879                 ret = btrfs_del_item(trans, root, path);
1880         }
1881         return ret;
1882 }
1883
1884 static int btrfs_issue_discard(struct block_device *bdev,
1885                                 u64 start, u64 len)
1886 {
1887         return blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_NOFS, 0);
1888 }
1889
1890 static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr,
1891                                 u64 num_bytes, u64 *actual_bytes)
1892 {
1893         int ret;
1894         u64 discarded_bytes = 0;
1895         struct btrfs_bio *bbio = NULL;
1896
1897
1898         /* Tell the block device(s) that the sectors can be discarded */
1899         ret = btrfs_map_block(root->fs_info, REQ_DISCARD,
1900                               bytenr, &num_bytes, &bbio, 0);
1901         /* Error condition is -ENOMEM */
1902         if (!ret) {
1903                 struct btrfs_bio_stripe *stripe = bbio->stripes;
1904                 int i;
1905
1906
1907                 for (i = 0; i < bbio->num_stripes; i++, stripe++) {
1908                         if (!stripe->dev->can_discard)
1909                                 continue;
1910
1911                         ret = btrfs_issue_discard(stripe->dev->bdev,
1912                                                   stripe->physical,
1913                                                   stripe->length);
1914                         if (!ret)
1915                                 discarded_bytes += stripe->length;
1916                         else if (ret != -EOPNOTSUPP)
1917                                 break; /* Logic errors or -ENOMEM, or -EIO but I don't know how that could happen JDM */
1918
1919                         /*
1920                          * Just in case we get back EOPNOTSUPP for some reason,
1921                          * just ignore the return value so we don't screw up
1922                          * people calling discard_extent.
1923                          */
1924                         ret = 0;
1925                 }
1926                 kfree(bbio);
1927         }
1928
1929         if (actual_bytes)
1930                 *actual_bytes = discarded_bytes;
1931
1932
1933         if (ret == -EOPNOTSUPP)
1934                 ret = 0;
1935         return ret;
1936 }
1937
1938 /* Can return -ENOMEM */
1939 int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
1940                          struct btrfs_root *root,
1941                          u64 bytenr, u64 num_bytes, u64 parent,
1942                          u64 root_objectid, u64 owner, u64 offset, int for_cow)
1943 {
1944         int ret;
1945         struct btrfs_fs_info *fs_info = root->fs_info;
1946
1947         BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID &&
1948                root_objectid == BTRFS_TREE_LOG_OBJECTID);
1949
1950         if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1951                 ret = btrfs_add_delayed_tree_ref(fs_info, trans, bytenr,
1952                                         num_bytes,
1953                                         parent, root_objectid, (int)owner,
1954                                         BTRFS_ADD_DELAYED_REF, NULL, for_cow);
1955         } else {
1956                 ret = btrfs_add_delayed_data_ref(fs_info, trans, bytenr,
1957                                         num_bytes,
1958                                         parent, root_objectid, owner, offset,
1959                                         BTRFS_ADD_DELAYED_REF, NULL, for_cow);
1960         }
1961         return ret;
1962 }
1963
1964 static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
1965                                   struct btrfs_root *root,
1966                                   u64 bytenr, u64 num_bytes,
1967                                   u64 parent, u64 root_objectid,
1968                                   u64 owner, u64 offset, int refs_to_add,
1969                                   struct btrfs_delayed_extent_op *extent_op)
1970 {
1971         struct btrfs_path *path;
1972         struct extent_buffer *leaf;
1973         struct btrfs_extent_item *item;
1974         u64 refs;
1975         int ret;
1976         int err = 0;
1977
1978         path = btrfs_alloc_path();
1979         if (!path)
1980                 return -ENOMEM;
1981
1982         path->reada = 1;
1983         path->leave_spinning = 1;
1984         /* this will setup the path even if it fails to insert the back ref */
1985         ret = insert_inline_extent_backref(trans, root->fs_info->extent_root,
1986                                            path, bytenr, num_bytes, parent,
1987                                            root_objectid, owner, offset,
1988                                            refs_to_add, extent_op);
1989         if (ret == 0)
1990                 goto out;
1991
1992         if (ret != -EAGAIN) {
1993                 err = ret;
1994                 goto out;
1995         }
1996
1997         leaf = path->nodes[0];
1998         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1999         refs = btrfs_extent_refs(leaf, item);
2000         btrfs_set_extent_refs(leaf, item, refs + refs_to_add);
2001         if (extent_op)
2002                 __run_delayed_extent_op(extent_op, leaf, item);
2003
2004         btrfs_mark_buffer_dirty(leaf);
2005         btrfs_release_path(path);
2006
2007         path->reada = 1;
2008         path->leave_spinning = 1;
2009
2010         /* now insert the actual backref */
2011         ret = insert_extent_backref(trans, root->fs_info->extent_root,
2012                                     path, bytenr, parent, root_objectid,
2013                                     owner, offset, refs_to_add);
2014         if (ret)
2015                 btrfs_abort_transaction(trans, root, ret);
2016 out:
2017         btrfs_free_path(path);
2018         return err;
2019 }
2020
2021 static int run_delayed_data_ref(struct btrfs_trans_handle *trans,
2022                                 struct btrfs_root *root,
2023                                 struct btrfs_delayed_ref_node *node,
2024                                 struct btrfs_delayed_extent_op *extent_op,
2025                                 int insert_reserved)
2026 {
2027         int ret = 0;
2028         struct btrfs_delayed_data_ref *ref;
2029         struct btrfs_key ins;
2030         u64 parent = 0;
2031         u64 ref_root = 0;
2032         u64 flags = 0;
2033
2034         ins.objectid = node->bytenr;
2035         ins.offset = node->num_bytes;
2036         ins.type = BTRFS_EXTENT_ITEM_KEY;
2037
2038         ref = btrfs_delayed_node_to_data_ref(node);
2039         if (node->type == BTRFS_SHARED_DATA_REF_KEY)
2040                 parent = ref->parent;
2041         else
2042                 ref_root = ref->root;
2043
2044         if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
2045                 if (extent_op)
2046                         flags |= extent_op->flags_to_set;
2047                 ret = alloc_reserved_file_extent(trans, root,
2048                                                  parent, ref_root, flags,
2049                                                  ref->objectid, ref->offset,
2050                                                  &ins, node->ref_mod);
2051         } else if (node->action == BTRFS_ADD_DELAYED_REF) {
2052                 ret = __btrfs_inc_extent_ref(trans, root, node->bytenr,
2053                                              node->num_bytes, parent,
2054                                              ref_root, ref->objectid,
2055                                              ref->offset, node->ref_mod,
2056                                              extent_op);
2057         } else if (node->action == BTRFS_DROP_DELAYED_REF) {
2058                 ret = __btrfs_free_extent(trans, root, node->bytenr,
2059                                           node->num_bytes, parent,
2060                                           ref_root, ref->objectid,
2061                                           ref->offset, node->ref_mod,
2062                                           extent_op);
2063         } else {
2064                 BUG();
2065         }
2066         return ret;
2067 }
2068
2069 static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
2070                                     struct extent_buffer *leaf,
2071                                     struct btrfs_extent_item *ei)
2072 {
2073         u64 flags = btrfs_extent_flags(leaf, ei);
2074         if (extent_op->update_flags) {
2075                 flags |= extent_op->flags_to_set;
2076                 btrfs_set_extent_flags(leaf, ei, flags);
2077         }
2078
2079         if (extent_op->update_key) {
2080                 struct btrfs_tree_block_info *bi;
2081                 BUG_ON(!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK));
2082                 bi = (struct btrfs_tree_block_info *)(ei + 1);
2083                 btrfs_set_tree_block_key(leaf, bi, &extent_op->key);
2084         }
2085 }
2086
2087 static int run_delayed_extent_op(struct btrfs_trans_handle *trans,
2088                                  struct btrfs_root *root,
2089                                  struct btrfs_delayed_ref_node *node,
2090                                  struct btrfs_delayed_extent_op *extent_op)
2091 {
2092         struct btrfs_key key;
2093         struct btrfs_path *path;
2094         struct btrfs_extent_item *ei;
2095         struct extent_buffer *leaf;
2096         u32 item_size;
2097         int ret;
2098         int err = 0;
2099         int metadata = (node->type == BTRFS_TREE_BLOCK_REF_KEY ||
2100                         node->type == BTRFS_SHARED_BLOCK_REF_KEY);
2101
2102         if (trans->aborted)
2103                 return 0;
2104
2105         if (metadata && !btrfs_fs_incompat(root->fs_info, SKINNY_METADATA))
2106                 metadata = 0;
2107
2108         path = btrfs_alloc_path();
2109         if (!path)
2110                 return -ENOMEM;
2111
2112         key.objectid = node->bytenr;
2113
2114         if (metadata) {
2115                 struct btrfs_delayed_tree_ref *tree_ref;
2116
2117                 tree_ref = btrfs_delayed_node_to_tree_ref(node);
2118                 key.type = BTRFS_METADATA_ITEM_KEY;
2119                 key.offset = tree_ref->level;
2120         } else {
2121                 key.type = BTRFS_EXTENT_ITEM_KEY;
2122                 key.offset = node->num_bytes;
2123         }
2124
2125 again:
2126         path->reada = 1;
2127         path->leave_spinning = 1;
2128         ret = btrfs_search_slot(trans, root->fs_info->extent_root, &key,
2129                                 path, 0, 1);
2130         if (ret < 0) {
2131                 err = ret;
2132                 goto out;
2133         }
2134         if (ret > 0) {
2135                 if (metadata) {
2136                         btrfs_release_path(path);
2137                         metadata = 0;
2138
2139                         key.offset = node->num_bytes;
2140                         key.type = BTRFS_EXTENT_ITEM_KEY;
2141                         goto again;
2142                 }
2143                 err = -EIO;
2144                 goto out;
2145         }
2146
2147         leaf = path->nodes[0];
2148         item_size = btrfs_item_size_nr(leaf, path->slots[0]);
2149 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
2150         if (item_size < sizeof(*ei)) {
2151                 ret = convert_extent_item_v0(trans, root->fs_info->extent_root,
2152                                              path, (u64)-1, 0);
2153                 if (ret < 0) {
2154                         err = ret;
2155                         goto out;
2156                 }
2157                 leaf = path->nodes[0];
2158                 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
2159         }
2160 #endif
2161         BUG_ON(item_size < sizeof(*ei));
2162         ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
2163         __run_delayed_extent_op(extent_op, leaf, ei);
2164
2165         btrfs_mark_buffer_dirty(leaf);
2166 out:
2167         btrfs_free_path(path);
2168         return err;
2169 }
2170
2171 static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,
2172                                 struct btrfs_root *root,
2173                                 struct btrfs_delayed_ref_node *node,
2174                                 struct btrfs_delayed_extent_op *extent_op,
2175                                 int insert_reserved)
2176 {
2177         int ret = 0;
2178         struct btrfs_delayed_tree_ref *ref;
2179         struct btrfs_key ins;
2180         u64 parent = 0;
2181         u64 ref_root = 0;
2182         bool skinny_metadata = btrfs_fs_incompat(root->fs_info,
2183                                                  SKINNY_METADATA);
2184
2185         ref = btrfs_delayed_node_to_tree_ref(node);
2186         if (node->type == BTRFS_SHARED_BLOCK_REF_KEY)
2187                 parent = ref->parent;
2188         else
2189                 ref_root = ref->root;
2190
2191         ins.objectid = node->bytenr;
2192         if (skinny_metadata) {
2193                 ins.offset = ref->level;
2194                 ins.type = BTRFS_METADATA_ITEM_KEY;
2195         } else {
2196                 ins.offset = node->num_bytes;
2197                 ins.type = BTRFS_EXTENT_ITEM_KEY;
2198         }
2199
2200         BUG_ON(node->ref_mod != 1);
2201         if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
2202                 BUG_ON(!extent_op || !extent_op->update_flags);
2203                 ret = alloc_reserved_tree_block(trans, root,
2204                                                 parent, ref_root,
2205                                                 extent_op->flags_to_set,
2206                                                 &extent_op->key,
2207                                                 ref->level, &ins);
2208         } else if (node->action == BTRFS_ADD_DELAYED_REF) {
2209                 ret = __btrfs_inc_extent_ref(trans, root, node->bytenr,
2210                                              node->num_bytes, parent, ref_root,
2211                                              ref->level, 0, 1, extent_op);
2212         } else if (node->action == BTRFS_DROP_DELAYED_REF) {
2213                 ret = __btrfs_free_extent(trans, root, node->bytenr,
2214                                           node->num_bytes, parent, ref_root,
2215                                           ref->level, 0, 1, extent_op);
2216         } else {
2217                 BUG();
2218         }
2219         return ret;
2220 }
2221
2222 /* helper function to actually process a single delayed ref entry */
2223 static int run_one_delayed_ref(struct btrfs_trans_handle *trans,
2224                                struct btrfs_root *root,
2225                                struct btrfs_delayed_ref_node *node,
2226                                struct btrfs_delayed_extent_op *extent_op,
2227                                int insert_reserved)
2228 {
2229         int ret = 0;
2230
2231         if (trans->aborted)
2232                 return 0;
2233
2234         if (btrfs_delayed_ref_is_head(node)) {
2235                 struct btrfs_delayed_ref_head *head;
2236                 /*
2237                  * we've hit the end of the chain and we were supposed
2238                  * to insert this extent into the tree.  But, it got
2239                  * deleted before we ever needed to insert it, so all
2240                  * we have to do is clean up the accounting
2241                  */
2242                 BUG_ON(extent_op);
2243                 head = btrfs_delayed_node_to_head(node);
2244                 if (insert_reserved) {
2245                         btrfs_pin_extent(root, node->bytenr,
2246                                          node->num_bytes, 1);
2247                         if (head->is_data) {
2248                                 ret = btrfs_del_csums(trans, root,
2249                                                       node->bytenr,
2250                                                       node->num_bytes);
2251                         }
2252                 }
2253                 return ret;
2254         }
2255
2256         if (node->type == BTRFS_TREE_BLOCK_REF_KEY ||
2257             node->type == BTRFS_SHARED_BLOCK_REF_KEY)
2258                 ret = run_delayed_tree_ref(trans, root, node, extent_op,
2259                                            insert_reserved);
2260         else if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||
2261                  node->type == BTRFS_SHARED_DATA_REF_KEY)
2262                 ret = run_delayed_data_ref(trans, root, node, extent_op,
2263                                            insert_reserved);
2264         else
2265                 BUG();
2266         return ret;
2267 }
2268
2269 static noinline struct btrfs_delayed_ref_node *
2270 select_delayed_ref(struct btrfs_delayed_ref_head *head)
2271 {
2272         struct rb_node *node;
2273         struct btrfs_delayed_ref_node *ref;
2274         int action = BTRFS_ADD_DELAYED_REF;
2275 again:
2276         /*
2277          * select delayed ref of type BTRFS_ADD_DELAYED_REF first.
2278          * this prevents ref count from going down to zero when
2279          * there still are pending delayed ref.
2280          */
2281         node = rb_prev(&head->node.rb_node);
2282         while (1) {
2283                 if (!node)
2284                         break;
2285                 ref = rb_entry(node, struct btrfs_delayed_ref_node,
2286                                 rb_node);
2287                 if (ref->bytenr != head->node.bytenr)
2288                         break;
2289                 if (ref->action == action)
2290                         return ref;
2291                 node = rb_prev(node);
2292         }
2293         if (action == BTRFS_ADD_DELAYED_REF) {
2294                 action = BTRFS_DROP_DELAYED_REF;
2295                 goto again;
2296         }
2297         return NULL;
2298 }
2299
2300 /*
2301  * Returns 0 on success or if called with an already aborted transaction.
2302  * Returns -ENOMEM or -EIO on failure and will abort the transaction.
2303  */
2304 static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
2305                                        struct btrfs_root *root,
2306                                        struct list_head *cluster)
2307 {
2308         struct btrfs_delayed_ref_root *delayed_refs;
2309         struct btrfs_delayed_ref_node *ref;
2310         struct btrfs_delayed_ref_head *locked_ref = NULL;
2311         struct btrfs_delayed_extent_op *extent_op;
2312         struct btrfs_fs_info *fs_info = root->fs_info;
2313         int ret;
2314         int count = 0;
2315         int must_insert_reserved = 0;
2316
2317         delayed_refs = &trans->transaction->delayed_refs;
2318         while (1) {
2319                 if (!locked_ref) {
2320                         /* pick a new head ref from the cluster list */
2321                         if (list_empty(cluster))
2322                                 break;
2323
2324                         locked_ref = list_entry(cluster->next,
2325                                      struct btrfs_delayed_ref_head, cluster);
2326
2327                         /* grab the lock that says we are going to process
2328                          * all the refs for this head */
2329                         ret = btrfs_delayed_ref_lock(trans, locked_ref);
2330
2331                         /*
2332                          * we may have dropped the spin lock to get the head
2333                          * mutex lock, and that might have given someone else
2334                          * time to free the head.  If that's true, it has been
2335                          * removed from our list and we can move on.
2336                          */
2337                         if (ret == -EAGAIN) {
2338                                 locked_ref = NULL;
2339                                 count++;
2340                                 continue;
2341                         }
2342                 }
2343
2344                 /*
2345                  * We need to try and merge add/drops of the same ref since we
2346                  * can run into issues with relocate dropping the implicit ref
2347                  * and then it being added back again before the drop can
2348                  * finish.  If we merged anything we need to re-loop so we can
2349                  * get a good ref.
2350                  */
2351                 btrfs_merge_delayed_refs(trans, fs_info, delayed_refs,
2352                                          locked_ref);
2353
2354                 /*
2355                  * locked_ref is the head node, so we have to go one
2356                  * node back for any delayed ref updates
2357                  */
2358                 ref = select_delayed_ref(locked_ref);
2359
2360                 if (ref && ref->seq &&
2361                     btrfs_check_delayed_seq(fs_info, delayed_refs, ref->seq)) {
2362                         /*
2363                          * there are still refs with lower seq numbers in the
2364                          * process of being added. Don't run this ref yet.
2365                          */
2366                         list_del_init(&locked_ref->cluster);
2367                         btrfs_delayed_ref_unlock(locked_ref);
2368                         locked_ref = NULL;
2369                         delayed_refs->num_heads_ready++;
2370                         spin_unlock(&delayed_refs->lock);
2371                         cond_resched();
2372                         spin_lock(&delayed_refs->lock);
2373                         continue;
2374                 }
2375
2376                 /*
2377                  * record the must insert reserved flag before we
2378                  * drop the spin lock.
2379                  */
2380                 must_insert_reserved = locked_ref->must_insert_reserved;
2381                 locked_ref->must_insert_reserved = 0;
2382
2383                 extent_op = locked_ref->extent_op;
2384                 locked_ref->extent_op = NULL;
2385
2386                 if (!ref) {
2387                         /* All delayed refs have been processed, Go ahead
2388                          * and send the head node to run_one_delayed_ref,
2389                          * so that any accounting fixes can happen
2390                          */
2391                         ref = &locked_ref->node;
2392
2393                         if (extent_op && must_insert_reserved) {
2394                                 btrfs_free_delayed_extent_op(extent_op);
2395                                 extent_op = NULL;
2396                         }
2397
2398                         if (extent_op) {
2399                                 spin_unlock(&delayed_refs->lock);
2400
2401                                 ret = run_delayed_extent_op(trans, root,
2402                                                             ref, extent_op);
2403                                 btrfs_free_delayed_extent_op(extent_op);
2404
2405                                 if (ret) {
2406                                         btrfs_debug(fs_info, "run_delayed_extent_op returned %d", ret);
2407                                         spin_lock(&delayed_refs->lock);
2408                                         btrfs_delayed_ref_unlock(locked_ref);
2409                                         return ret;
2410                                 }
2411
2412                                 goto next;
2413                         }
2414                 }
2415
2416                 ref->in_tree = 0;
2417                 rb_erase(&ref->rb_node, &delayed_refs->root);
2418                 delayed_refs->num_entries--;
2419                 if (!btrfs_delayed_ref_is_head(ref)) {
2420                         /*
2421                          * when we play the delayed ref, also correct the
2422                          * ref_mod on head
2423                          */
2424                         switch (ref->action) {
2425                         case BTRFS_ADD_DELAYED_REF:
2426                         case BTRFS_ADD_DELAYED_EXTENT:
2427                                 locked_ref->node.ref_mod -= ref->ref_mod;
2428                                 break;
2429                         case BTRFS_DROP_DELAYED_REF:
2430                                 locked_ref->node.ref_mod += ref->ref_mod;
2431                                 break;
2432                         default:
2433                                 WARN_ON(1);
2434                         }
2435                 }
2436                 spin_unlock(&delayed_refs->lock);
2437
2438                 ret = run_one_delayed_ref(trans, root, ref, extent_op,
2439                                           must_insert_reserved);
2440
2441                 btrfs_free_delayed_extent_op(extent_op);
2442                 if (ret) {
2443                         btrfs_delayed_ref_unlock(locked_ref);
2444                         btrfs_put_delayed_ref(ref);
2445                         btrfs_debug(fs_info, "run_one_delayed_ref returned %d", ret);
2446                         spin_lock(&delayed_refs->lock);
2447                         return ret;
2448                 }
2449
2450                 /*
2451                  * If this node is a head, that means all the refs in this head
2452                  * have been dealt with, and we will pick the next head to deal
2453                  * with, so we must unlock the head and drop it from the cluster
2454                  * list before we release it.
2455                  */
2456                 if (btrfs_delayed_ref_is_head(ref)) {
2457                         list_del_init(&locked_ref->cluster);
2458                         btrfs_delayed_ref_unlock(locked_ref);
2459                         locked_ref = NULL;
2460                 }
2461                 btrfs_put_delayed_ref(ref);
2462                 count++;
2463 next:
2464                 cond_resched();
2465                 spin_lock(&delayed_refs->lock);
2466         }
2467         return count;
2468 }
2469
2470 #ifdef SCRAMBLE_DELAYED_REFS
2471 /*
2472  * Normally delayed refs get processed in ascending bytenr order. This
2473  * correlates in most cases to the order added. To expose dependencies on this
2474  * order, we start to process the tree in the middle instead of the beginning
2475  */
2476 static u64 find_middle(struct rb_root *root)
2477 {
2478         struct rb_node *n = root->rb_node;
2479         struct btrfs_delayed_ref_node *entry;
2480         int alt = 1;
2481         u64 middle;
2482         u64 first = 0, last = 0;
2483
2484         n = rb_first(root);
2485         if (n) {
2486                 entry = rb_entry(n, struct btrfs_delayed_ref_node, rb_node);
2487                 first = entry->bytenr;
2488         }
2489         n = rb_last(root);
2490         if (n) {
2491                 entry = rb_entry(n, struct btrfs_delayed_ref_node, rb_node);
2492                 last = entry->bytenr;
2493         }
2494         n = root->rb_node;
2495
2496         while (n) {
2497                 entry = rb_entry(n, struct btrfs_delayed_ref_node, rb_node);
2498                 WARN_ON(!entry->in_tree);
2499
2500                 middle = entry->bytenr;
2501
2502                 if (alt)
2503                         n = n->rb_left;
2504                 else
2505                         n = n->rb_right;
2506
2507                 alt = 1 - alt;
2508         }
2509         return middle;
2510 }
2511 #endif
2512
2513 int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans,
2514                                          struct btrfs_fs_info *fs_info)
2515 {
2516         struct qgroup_update *qgroup_update;
2517         int ret = 0;
2518
2519         if (list_empty(&trans->qgroup_ref_list) !=
2520             !trans->delayed_ref_elem.seq) {
2521                 /* list without seq or seq without list */
2522                 btrfs_err(fs_info,
2523                         "qgroup accounting update error, list is%s empty, seq is %llu",
2524                         list_empty(&trans->qgroup_ref_list) ? "" : " not",
2525                         trans->delayed_ref_elem.seq);
2526                 BUG();
2527         }
2528
2529         if (!trans->delayed_ref_elem.seq)
2530                 return 0;
2531
2532         while (!list_empty(&trans->qgroup_ref_list)) {
2533                 qgroup_update = list_first_entry(&trans->qgroup_ref_list,
2534                                                  struct qgroup_update, list);
2535                 list_del(&qgroup_update->list);
2536                 if (!ret)
2537                         ret = btrfs_qgroup_account_ref(
2538                                         trans, fs_info, qgroup_update->node,
2539                                         qgroup_update->extent_op);
2540                 kfree(qgroup_update);
2541         }
2542
2543         btrfs_put_tree_mod_seq(fs_info, &trans->delayed_ref_elem);
2544
2545         return ret;
2546 }
2547
2548 static int refs_newer(struct btrfs_delayed_ref_root *delayed_refs, int seq,
2549                       int count)
2550 {
2551         int val = atomic_read(&delayed_refs->ref_seq);
2552
2553         if (val < seq || val >= seq + count)
2554                 return 1;
2555         return 0;
2556 }
2557
2558 /*
2559  * this starts processing the delayed reference count updates and
2560  * extent insertions we have queued up so far.  count can be
2561  * 0, which means to process everything in the tree at the start
2562  * of the run (but not newly added entries), or it can be some target
2563  * number you'd like to process.
2564  *
2565  * Returns 0 on success or if called with an aborted transaction
2566  * Returns <0 on error and aborts the transaction
2567  */
2568 int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2569                            struct btrfs_root *root, unsigned long count)
2570 {
2571         struct rb_node *node;
2572         struct btrfs_delayed_ref_root *delayed_refs;
2573         struct btrfs_delayed_ref_node *ref;
2574         struct list_head cluster;
2575         int ret;
2576         u64 delayed_start;
2577         int run_all = count == (unsigned long)-1;
2578         int run_most = 0;
2579         int loops;
2580
2581         /* We'll clean this up in btrfs_cleanup_transaction */
2582         if (trans->aborted)
2583                 return 0;
2584
2585         if (root == root->fs_info->extent_root)
2586                 root = root->fs_info->tree_root;
2587
2588         btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info);
2589
2590         delayed_refs = &trans->transaction->delayed_refs;
2591         INIT_LIST_HEAD(&cluster);
2592         if (count == 0) {
2593                 count = delayed_refs->num_entries * 2;
2594                 run_most = 1;
2595         }
2596
2597         if (!run_all && !run_most) {
2598                 int old;
2599                 int seq = atomic_read(&delayed_refs->ref_seq);
2600
2601 progress:
2602                 old = atomic_cmpxchg(&delayed_refs->procs_running_refs, 0, 1);
2603                 if (old) {
2604                         DEFINE_WAIT(__wait);
2605                         if (delayed_refs->num_entries < 16348)
2606                                 return 0;
2607
2608                         prepare_to_wait(&delayed_refs->wait, &__wait,
2609                                         TASK_UNINTERRUPTIBLE);
2610
2611                         old = atomic_cmpxchg(&delayed_refs->procs_running_refs, 0, 1);
2612                         if (old) {
2613                                 schedule();
2614                                 finish_wait(&delayed_refs->wait, &__wait);
2615
2616                                 if (!refs_newer(delayed_refs, seq, 256))
2617                                         goto progress;
2618                                 else
2619                                         return 0;
2620                         } else {
2621                                 finish_wait(&delayed_refs->wait, &__wait);
2622                                 goto again;
2623                         }
2624                 }
2625
2626         } else {
2627                 atomic_inc(&delayed_refs->procs_running_refs);
2628         }
2629
2630 again:
2631         loops = 0;
2632         spin_lock(&delayed_refs->lock);
2633
2634 #ifdef SCRAMBLE_DELAYED_REFS
2635         delayed_refs->run_delayed_start = find_middle(&delayed_refs->root);
2636 #endif
2637
2638         while (1) {
2639                 if (!(run_all || run_most) &&
2640                     delayed_refs->num_heads_ready < 64)
2641                         break;
2642
2643                 /*
2644                  * go find something we can process in the rbtree.  We start at
2645                  * the beginning of the tree, and then build a cluster
2646                  * of refs to process starting at the first one we are able to
2647                  * lock
2648                  */
2649                 delayed_start = delayed_refs->run_delayed_start;
2650                 ret = btrfs_find_ref_cluster(trans, &cluster,
2651                                              delayed_refs->run_delayed_start);
2652                 if (ret)
2653                         break;
2654
2655                 ret = run_clustered_refs(trans, root, &cluster);
2656                 if (ret < 0) {
2657                         btrfs_release_ref_cluster(&cluster);
2658                         spin_unlock(&delayed_refs->lock);
2659                         btrfs_abort_transaction(trans, root, ret);
2660                         atomic_dec(&delayed_refs->procs_running_refs);
2661                         return ret;
2662                 }
2663
2664                 atomic_add(ret, &delayed_refs->ref_seq);
2665
2666                 count -= min_t(unsigned long, ret, count);
2667
2668                 if (count == 0)
2669                         break;
2670
2671                 if (delayed_start >= delayed_refs->run_delayed_start) {
2672                         if (loops == 0) {
2673                                 /*
2674                                  * btrfs_find_ref_cluster looped. let's do one
2675                                  * more cycle. if we don't run any delayed ref
2676                                  * during that cycle (because we can't because
2677                                  * all of them are blocked), bail out.
2678                                  */
2679                                 loops = 1;
2680                         } else {
2681                                 /*
2682                                  * no runnable refs left, stop trying
2683                                  */
2684                                 BUG_ON(run_all);
2685                                 break;
2686                         }
2687                 }
2688                 if (ret) {
2689                         /* refs were run, let's reset staleness detection */
2690                         loops = 0;
2691                 }
2692         }
2693
2694         if (run_all) {
2695                 if (!list_empty(&trans->new_bgs)) {
2696                         spin_unlock(&delayed_refs->lock);
2697                         btrfs_create_pending_block_groups(trans, root);
2698                         spin_lock(&delayed_refs->lock);
2699                 }
2700
2701                 node = rb_first(&delayed_refs->root);
2702                 if (!node)
2703                         goto out;
2704                 count = (unsigned long)-1;
2705
2706                 while (node) {
2707                         ref = rb_entry(node, struct btrfs_delayed_ref_node,
2708                                        rb_node);
2709                         if (btrfs_delayed_ref_is_head(ref)) {
2710                                 struct btrfs_delayed_ref_head *head;
2711
2712                                 head = btrfs_delayed_node_to_head(ref);
2713                                 atomic_inc(&ref->refs);
2714
2715                                 spin_unlock(&delayed_refs->lock);
2716                                 /*
2717                                  * Mutex was contended, block until it's
2718                                  * released and try again
2719                                  */
2720                                 mutex_lock(&head->mutex);
2721                                 mutex_unlock(&head->mutex);
2722
2723                                 btrfs_put_delayed_ref(ref);
2724                                 cond_resched();
2725                                 goto again;
2726                         }
2727                         node = rb_next(node);
2728                 }
2729                 spin_unlock(&delayed_refs->lock);
2730                 schedule_timeout(1);
2731                 goto again;
2732         }
2733 out:
2734         atomic_dec(&delayed_refs->procs_running_refs);
2735         smp_mb();
2736         if (waitqueue_active(&delayed_refs->wait))
2737                 wake_up(&delayed_refs->wait);
2738
2739         spin_unlock(&delayed_refs->lock);
2740         assert_qgroups_uptodate(trans);
2741         return 0;
2742 }
2743
2744 int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2745                                 struct btrfs_root *root,
2746                                 u64 bytenr, u64 num_bytes, u64 flags,
2747                                 int is_data)
2748 {
2749         struct btrfs_delayed_extent_op *extent_op;
2750         int ret;
2751
2752         extent_op = btrfs_alloc_delayed_extent_op();
2753         if (!extent_op)
2754                 return -ENOMEM;
2755
2756         extent_op->flags_to_set = flags;
2757         extent_op->update_flags = 1;
2758         extent_op->update_key = 0;
2759         extent_op->is_data = is_data ? 1 : 0;
2760
2761         ret = btrfs_add_delayed_extent_op(root->fs_info, trans, bytenr,
2762                                           num_bytes, extent_op);
2763         if (ret)
2764                 btrfs_free_delayed_extent_op(extent_op);
2765         return ret;
2766 }
2767
2768 static noinline int check_delayed_ref(struct btrfs_trans_handle *trans,
2769                                       struct btrfs_root *root,
2770                                       struct btrfs_path *path,
2771                                       u64 objectid, u64 offset, u64 bytenr)
2772 {
2773         struct btrfs_delayed_ref_head *head;
2774         struct btrfs_delayed_ref_node *ref;
2775         struct btrfs_delayed_data_ref *data_ref;
2776         struct btrfs_delayed_ref_root *delayed_refs;
2777         struct rb_node *node;
2778         int ret = 0;
2779
2780         ret = -ENOENT;
2781         delayed_refs = &trans->transaction->delayed_refs;
2782         spin_lock(&delayed_refs->lock);
2783         head = btrfs_find_delayed_ref_head(trans, bytenr);
2784         if (!head)
2785                 goto out;
2786
2787         if (!mutex_trylock(&head->mutex)) {
2788                 atomic_inc(&head->node.refs);
2789                 spin_unlock(&delayed_refs->lock);
2790
2791                 btrfs_release_path(path);
2792
2793                 /*
2794                  * Mutex was contended, block until it's released and let
2795                  * caller try again
2796                  */
2797                 mutex_lock(&head->mutex);
2798                 mutex_unlock(&head->mutex);
2799                 btrfs_put_delayed_ref(&head->node);
2800                 return -EAGAIN;
2801         }
2802
2803         node = rb_prev(&head->node.rb_node);
2804         if (!node)
2805                 goto out_unlock;
2806
2807         ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
2808
2809         if (ref->bytenr != bytenr)
2810                 goto out_unlock;
2811
2812         ret = 1;
2813         if (ref->type != BTRFS_EXTENT_DATA_REF_KEY)
2814                 goto out_unlock;
2815
2816         data_ref = btrfs_delayed_node_to_data_ref(ref);
2817
2818         node = rb_prev(node);
2819         if (node) {
2820                 int seq = ref->seq;
2821
2822                 ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
2823                 if (ref->bytenr == bytenr && ref->seq == seq)
2824                         goto out_unlock;
2825         }
2826
2827         if (data_ref->root != root->root_key.objectid ||
2828             data_ref->objectid != objectid || data_ref->offset != offset)
2829                 goto out_unlock;
2830
2831         ret = 0;
2832 out_unlock:
2833         mutex_unlock(&head->mutex);
2834 out:
2835         spin_unlock(&delayed_refs->lock);
2836         return ret;
2837 }
2838
2839 static noinline int check_committed_ref(struct btrfs_trans_handle *trans,
2840                                         struct btrfs_root *root,
2841                                         struct btrfs_path *path,
2842                                         u64 objectid, u64 offset, u64 bytenr)
2843 {
2844         struct btrfs_root *extent_root = root->fs_info->extent_root;
2845         struct extent_buffer *leaf;
2846         struct btrfs_extent_data_ref *ref;
2847         struct btrfs_extent_inline_ref *iref;
2848         struct btrfs_extent_item *ei;
2849         struct btrfs_key key;
2850         u32 item_size;
2851         int ret;
2852
2853         key.objectid = bytenr;
2854         key.offset = (u64)-1;
2855         key.type = BTRFS_EXTENT_ITEM_KEY;
2856
2857         ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
2858         if (ret < 0)
2859                 goto out;
2860         BUG_ON(ret == 0); /* Corruption */
2861
2862         ret = -ENOENT;
2863         if (path->slots[0] == 0)
2864                 goto out;
2865
2866         path->slots[0]--;
2867         leaf = path->nodes[0];
2868         btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2869
2870         if (key.objectid != bytenr || key.type != BTRFS_EXTENT_ITEM_KEY)
2871                 goto out;
2872
2873         ret = 1;
2874         item_size = btrfs_item_size_nr(leaf, path->slots[0]);
2875 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
2876         if (item_size < sizeof(*ei)) {
2877                 WARN_ON(item_size != sizeof(struct btrfs_extent_item_v0));
2878                 goto out;
2879         }
2880 #endif
2881         ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
2882
2883         if (item_size != sizeof(*ei) +
2884             btrfs_extent_inline_ref_size(BTRFS_EXTENT_DATA_REF_KEY))
2885                 goto out;
2886
2887         if (btrfs_extent_generation(leaf, ei) <=
2888             btrfs_root_last_snapshot(&root->root_item))
2889                 goto out;
2890
2891         iref = (struct btrfs_extent_inline_ref *)(ei + 1);
2892         if (btrfs_extent_inline_ref_type(leaf, iref) !=
2893             BTRFS_EXTENT_DATA_REF_KEY)
2894                 goto out;
2895
2896         ref = (struct btrfs_extent_data_ref *)(&iref->offset);
2897         if (btrfs_extent_refs(leaf, ei) !=
2898             btrfs_extent_data_ref_count(leaf, ref) ||
2899             btrfs_extent_data_ref_root(leaf, ref) !=
2900             root->root_key.objectid ||
2901             btrfs_extent_data_ref_objectid(leaf, ref) != objectid ||
2902             btrfs_extent_data_ref_offset(leaf, ref) != offset)
2903                 goto out;
2904
2905         ret = 0;
2906 out:
2907         return ret;
2908 }
2909
2910 int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
2911                           struct btrfs_root *root,
2912                           u64 objectid, u64 offset, u64 bytenr)
2913 {
2914         struct btrfs_path *path;
2915         int ret;
2916         int ret2;
2917
2918         path = btrfs_alloc_path();
2919         if (!path)
2920                 return -ENOENT;
2921
2922         do {
2923                 ret = check_committed_ref(trans, root, path, objectid,
2924                                           offset, bytenr);
2925                 if (ret && ret != -ENOENT)
2926                         goto out;
2927
2928                 ret2 = check_delayed_ref(trans, root, path, objectid,
2929                                          offset, bytenr);
2930         } while (ret2 == -EAGAIN);
2931
2932         if (ret2 && ret2 != -ENOENT) {
2933                 ret = ret2;
2934                 goto out;
2935         }
2936
2937         if (ret != -ENOENT || ret2 != -ENOENT)
2938                 ret = 0;
2939 out:
2940         btrfs_free_path(path);
2941         if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
2942                 WARN_ON(ret > 0);
2943         return ret;
2944 }
2945
2946 static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,
2947                            struct btrfs_root *root,
2948                            struct extent_buffer *buf,
2949                            int full_backref, int inc, int for_cow)
2950 {
2951         u64 bytenr;
2952         u64 num_bytes;
2953         u64 parent;
2954         u64 ref_root;
2955         u32 nritems;
2956         struct btrfs_key key;
2957         struct btrfs_file_extent_item *fi;
2958         int i;
2959         int level;
2960         int ret = 0;
2961         int (*process_func)(struct btrfs_trans_handle *, struct btrfs_root *,
2962                             u64, u64, u64, u64, u64, u64, int);
2963
2964         ref_root = btrfs_header_owner(buf);
2965         nritems = btrfs_header_nritems(buf);
2966         level = btrfs_header_level(buf);
2967
2968         if (!root->ref_cows && level == 0)
2969                 return 0;
2970
2971         if (inc)
2972                 process_func = btrfs_inc_extent_ref;
2973         else
2974                 process_func = btrfs_free_extent;
2975
2976         if (full_backref)
2977                 parent = buf->start;
2978         else
2979                 parent = 0;
2980
2981         for (i = 0; i < nritems; i++) {
2982                 if (level == 0) {
2983                         btrfs_item_key_to_cpu(buf, &key, i);
2984                         if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
2985                                 continue;
2986                         fi = btrfs_item_ptr(buf, i,
2987                                             struct btrfs_file_extent_item);
2988                         if (btrfs_file_extent_type(buf, fi) ==
2989                             BTRFS_FILE_EXTENT_INLINE)
2990                                 continue;
2991                         bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
2992                         if (bytenr == 0)
2993                                 continue;
2994
2995                         num_bytes = btrfs_file_extent_disk_num_bytes(buf, fi);
2996                         key.offset -= btrfs_file_extent_offset(buf, fi);
2997                         ret = process_func(trans, root, bytenr, num_bytes,
2998                                            parent, ref_root, key.objectid,
2999                                            key.offset, for_cow);
3000                         if (ret)
3001                                 goto fail;
3002                 } else {
3003                         bytenr = btrfs_node_blockptr(buf, i);
3004                         num_bytes = btrfs_level_size(root, level - 1);
3005                         ret = process_func(trans, root, bytenr, num_bytes,
3006                                            parent, ref_root, level - 1, 0,
3007                                            for_cow);
3008                         if (ret)
3009                                 goto fail;
3010                 }
3011         }
3012         return 0;
3013 fail:
3014         return ret;
3015 }
3016
3017 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3018                   struct extent_buffer *buf, int full_backref, int for_cow)
3019 {
3020         return __btrfs_mod_ref(trans, root, buf, full_backref, 1, for_cow);
3021 }
3022
3023 int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3024                   struct extent_buffer *buf, int full_backref, int for_cow)
3025 {
3026         return __btrfs_mod_ref(trans, root, buf, full_backref, 0, for_cow);
3027 }
3028
3029 static int write_one_cache_group(struct btrfs_trans_handle *trans,
3030                                  struct btrfs_root *root,
3031                                  struct btrfs_path *path,
3032                                  struct btrfs_block_group_cache *cache)
3033 {
3034         int ret;
3035         struct btrfs_root *extent_root = root->fs_info->extent_root;
3036         unsigned long bi;
3037         struct extent_buffer *leaf;
3038
3039         ret = btrfs_search_slot(trans, extent_root, &cache->key, path, 0, 1);
3040         if (ret < 0)
3041                 goto fail;
3042         BUG_ON(ret); /* Corruption */
3043
3044         leaf = path->nodes[0];
3045         bi = btrfs_item_ptr_offset(leaf, path->slots[0]);
3046         write_extent_buffer(leaf, &cache->item, bi, sizeof(cache->item));
3047         btrfs_mark_buffer_dirty(leaf);
3048         btrfs_release_path(path);
3049 fail:
3050         if (ret) {
3051                 btrfs_abort_transaction(trans, root, ret);
3052                 return ret;
3053         }
3054         return 0;
3055
3056 }
3057
3058 static struct btrfs_block_group_cache *
3059 next_block_group(struct btrfs_root *root,
3060                  struct btrfs_block_group_cache *cache)
3061 {
3062         struct rb_node *node;
3063         spin_lock(&root->fs_info->block_group_cache_lock);
3064         node = rb_next(&cache->cache_node);
3065         btrfs_put_block_group(cache);
3066         if (node) {
3067                 cache = rb_entry(node, struct btrfs_block_group_cache,
3068                                  cache_node);
3069                 btrfs_get_block_group(cache);
3070         } else
3071                 cache = NULL;
3072         spin_unlock(&root->fs_info->block_group_cache_lock);
3073         return cache;
3074 }
3075
3076 static int cache_save_setup(struct btrfs_block_group_cache *block_group,
3077                             struct btrfs_trans_handle *trans,
3078                             struct btrfs_path *path)
3079 {
3080         struct btrfs_root *root = block_group->fs_info->tree_root;
3081         struct inode *inode = NULL;
3082         u64 alloc_hint = 0;
3083         int dcs = BTRFS_DC_ERROR;
3084         int num_pages = 0;
3085         int retries = 0;
3086         int ret = 0;
3087
3088         /*
3089          * If this block group is smaller than 100 megs don't bother caching the
3090          * block group.
3091          */
3092         if (block_group->key.offset < (100 * 1024 * 1024)) {
3093                 spin_lock(&block_group->lock);
3094                 block_group->disk_cache_state = BTRFS_DC_WRITTEN;
3095                 spin_unlock(&block_group->lock);
3096                 return 0;
3097         }
3098
3099 again:
3100         inode = lookup_free_space_inode(root, block_group, path);
3101         if (IS_ERR(inode) && PTR_ERR(inode) != -ENOENT) {
3102                 ret = PTR_ERR(inode);
3103                 btrfs_release_path(path);
3104                 goto out;
3105         }
3106
3107         if (IS_ERR(inode)) {
3108                 BUG_ON(retries);
3109                 retries++;
3110
3111                 if (block_group->ro)
3112                         goto out_free;
3113
3114                 ret = create_free_space_inode(root, trans, block_group, path);
3115                 if (ret)
3116                         goto out_free;
3117                 goto again;
3118         }
3119
3120         /* We've already setup this transaction, go ahead and exit */
3121         if (block_group->cache_generation == trans->transid &&
3122             i_size_read(inode)) {
3123                 dcs = BTRFS_DC_SETUP;
3124                 goto out_put;
3125         }
3126
3127         /*
3128          * We want to set the generation to 0, that way if anything goes wrong
3129          * from here on out we know not to trust this cache when we load up next
3130          * time.
3131          */
3132         BTRFS_I(inode)->generation = 0;
3133         ret = btrfs_update_inode(trans, root, inode);
3134         WARN_ON(ret);
3135
3136         if (i_size_read(inode) > 0) {
3137                 ret = btrfs_truncate_free_space_cache(root, trans, path,
3138                                                       inode);
3139                 if (ret)
3140                         goto out_put;
3141         }
3142
3143         spin_lock(&block_group->lock);
3144         if (block_group->cached != BTRFS_CACHE_FINISHED ||
3145             !btrfs_test_opt(root, SPACE_CACHE)) {
3146                 /*
3147                  * don't bother trying to write stuff out _if_
3148                  * a) we're not cached,
3149                  * b) we're with nospace_cache mount option.
3150                  */
3151                 dcs = BTRFS_DC_WRITTEN;
3152                 spin_unlock(&block_group->lock);
3153                 goto out_put;
3154         }
3155         spin_unlock(&block_group->lock);
3156
3157         /*
3158          * Try to preallocate enough space based on how big the block group is.
3159          * Keep in mind this has to include any pinned space which could end up
3160          * taking up quite a bit since it's not folded into the other space
3161          * cache.
3162          */
3163         num_pages = (int)div64_u64(block_group->key.offset, 256 * 1024 * 1024);
3164         if (!num_pages)
3165                 num_pages = 1;
3166
3167         num_pages *= 16;
3168         num_pages *= PAGE_CACHE_SIZE;
3169
3170         ret = btrfs_check_data_free_space(inode, num_pages);
3171         if (ret)
3172                 goto out_put;
3173
3174         ret = btrfs_prealloc_file_range_trans(inode, trans, 0, 0, num_pages,
3175                                               num_pages, num_pages,
3176                                               &alloc_hint);
3177         if (!ret)
3178                 dcs = BTRFS_DC_SETUP;
3179         btrfs_free_reserved_data_space(inode, num_pages);
3180
3181 out_put:
3182         iput(inode);
3183 out_free:
3184         btrfs_release_path(path);
3185 out:
3186         spin_lock(&block_group->lock);
3187         if (!ret && dcs == BTRFS_DC_SETUP)
3188                 block_group->cache_generation = trans->transid;
3189         block_group->disk_cache_state = dcs;
3190         spin_unlock(&block_group->lock);
3191
3192         return ret;
3193 }
3194
3195 int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
3196                                    struct btrfs_root *root)
3197 {
3198         struct btrfs_block_group_cache *cache;
3199         int err = 0;
3200         struct btrfs_path *path;
3201         u64 last = 0;
3202
3203         path = btrfs_alloc_path();
3204         if (!path)
3205                 return -ENOMEM;
3206
3207 again:
3208         while (1) {
3209                 cache = btrfs_lookup_first_block_group(root->fs_info, last);
3210                 while (cache) {
3211                         if (cache->disk_cache_state == BTRFS_DC_CLEAR)
3212                                 break;
3213                         cache = next_block_group(root, cache);
3214                 }
3215                 if (!cache) {
3216                         if (last == 0)
3217                                 break;
3218                         last = 0;
3219                         continue;
3220                 }
3221                 err = cache_save_setup(cache, trans, path);
3222                 last = cache->key.objectid + cache->key.offset;
3223                 btrfs_put_block_group(cache);
3224         }
3225
3226         while (1) {
3227                 if (last == 0) {
3228                         err = btrfs_run_delayed_refs(trans, root,
3229                                                      (unsigned long)-1);
3230                         if (err) /* File system offline */
3231                                 goto out;
3232                 }
3233
3234                 cache = btrfs_lookup_first_block_group(root->fs_info, last);
3235                 while (cache) {
3236                         if (cache->disk_cache_state == BTRFS_DC_CLEAR) {
3237                                 btrfs_put_block_group(cache);
3238                                 goto again;
3239                         }
3240
3241                         if (cache->dirty)
3242                                 break;
3243                         cache = next_block_group(root, cache);
3244                 }
3245                 if (!cache) {
3246                         if (last == 0)
3247                                 break;
3248                         last = 0;
3249                         continue;
3250                 }
3251
3252                 if (cache->disk_cache_state == BTRFS_DC_SETUP)
3253                         cache->disk_cache_state = BTRFS_DC_NEED_WRITE;
3254                 cache->dirty = 0;
3255                 last = cache->key.objectid + cache->key.offset;
3256
3257                 err = write_one_cache_group(trans, root, path, cache);
3258                 if (err) /* File system offline */
3259                         goto out;
3260
3261                 btrfs_put_block_group(cache);
3262         }
3263
3264         while (1) {
3265                 /*
3266                  * I don't think this is needed since we're just marking our
3267                  * preallocated extent as written, but just in case it can't
3268                  * hurt.
3269                  */
3270                 if (last == 0) {
3271                         err = btrfs_run_delayed_refs(trans, root,
3272                                                      (unsigned long)-1);
3273                         if (err) /* File system offline */
3274                                 goto out;
3275                 }
3276
3277                 cache = btrfs_lookup_first_block_group(root->fs_info, last);
3278                 while (cache) {
3279                         /*
3280                          * Really this shouldn't happen, but it could if we
3281                          * couldn't write the entire preallocated extent and
3282                          * splitting the extent resulted in a new block.
3283                          */
3284                         if (cache->dirty) {
3285                                 btrfs_put_block_group(cache);
3286                                 goto again;
3287                         }
3288                         if (cache->disk_cache_state == BTRFS_DC_NEED_WRITE)
3289                                 break;
3290                         cache = next_block_group(root, cache);
3291                 }
3292                 if (!cache) {
3293                         if (last == 0)
3294                                 break;
3295                         last = 0;
3296                         continue;
3297                 }
3298
3299                 err = btrfs_write_out_cache(root, trans, cache, path);
3300
3301                 /*
3302                  * If we didn't have an error then the cache state is still
3303                  * NEED_WRITE, so we can set it to WRITTEN.
3304                  */
3305                 if (!err && cache->disk_cache_state == BTRFS_DC_NEED_WRITE)
3306                         cache->disk_cache_state = BTRFS_DC_WRITTEN;
3307                 last = cache->key.objectid + cache->key.offset;
3308                 btrfs_put_block_group(cache);
3309         }
3310 out:
3311
3312         btrfs_free_path(path);
3313         return err;
3314 }
3315
3316 int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr)
3317 {
3318         struct btrfs_block_group_cache *block_group;
3319         int readonly = 0;
3320
3321         block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
3322         if (!block_group || block_group->ro)
3323                 readonly = 1;
3324         if (block_group)
3325                 btrfs_put_block_group(block_group);
3326         return readonly;
3327 }
3328
3329 static int update_space_info(struct btrfs_fs_info *info, u64 flags,
3330                              u64 total_bytes, u64 bytes_used,
3331                              struct btrfs_space_info **space_info)
3332 {
3333         struct btrfs_space_info *found;
3334         int i;
3335         int factor;
3336
3337         if (flags & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1 |
3338                      BTRFS_BLOCK_GROUP_RAID10))
3339                 factor = 2;
3340         else
3341                 factor = 1;
3342
3343         found = __find_space_info(info, flags);
3344         if (found) {
3345                 spin_lock(&found->lock);
3346                 found->total_bytes += total_bytes;
3347                 found->disk_total += total_bytes * factor;
3348                 found->bytes_used += bytes_used;
3349                 found->disk_used += bytes_used * factor;
3350                 found->full = 0;
3351                 spin_unlock(&found->lock);
3352                 *space_info = found;
3353                 return 0;
3354         }
3355         found = kzalloc(sizeof(*found), GFP_NOFS);
3356         if (!found)
3357                 return -ENOMEM;
3358
3359         for (i = 0; i < BTRFS_NR_RAID_TYPES; i++)
3360                 INIT_LIST_HEAD(&found->block_groups[i]);
3361         init_rwsem(&found->groups_sem);
3362         spin_lock_init(&found->lock);
3363         found->flags = flags & BTRFS_BLOCK_GROUP_TYPE_MASK;
3364         found->total_bytes = total_bytes;
3365         found->disk_total = total_bytes * factor;
3366         found->bytes_used = bytes_used;
3367         found->disk_used = bytes_used * factor;
3368         found->bytes_pinned = 0;
3369         found->bytes_reserved = 0;
3370         found->bytes_readonly = 0;
3371         found->bytes_may_use = 0;
3372         found->full = 0;
3373         found->force_alloc = CHUNK_ALLOC_NO_FORCE;
3374         found->chunk_alloc = 0;
3375         found->flush = 0;
3376         init_waitqueue_head(&found->wait);
3377         *space_info = found;
3378         list_add_rcu(&found->list, &info->space_info);
3379         if (flags & BTRFS_BLOCK_GROUP_DATA)
3380                 info->data_sinfo = found;
3381         return 0;
3382 }
3383
3384 static void set_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)
3385 {
3386         u64 extra_flags = chunk_to_extended(flags) &
3387                                 BTRFS_EXTENDED_PROFILE_MASK;
3388
3389         write_seqlock(&fs_info->profiles_lock);
3390         if (flags & BTRFS_BLOCK_GROUP_DATA)
3391                 fs_info->avail_data_alloc_bits |= extra_flags;
3392         if (flags & BTRFS_BLOCK_GROUP_METADATA)
3393                 fs_info->avail_metadata_alloc_bits |= extra_flags;
3394         if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
3395                 fs_info->avail_system_alloc_bits |= extra_flags;
3396         write_sequnlock(&fs_info->profiles_lock);
3397 }
3398
3399 /*
3400  * returns target flags in extended format or 0 if restripe for this
3401  * chunk_type is not in progress
3402  *
3403  * should be called with either volume_mutex or balance_lock held
3404  */
3405 static u64 get_restripe_target(struct btrfs_fs_info *fs_info, u64 flags)
3406 {
3407         struct btrfs_balance_control *bctl = fs_info->balance_ctl;
3408         u64 target = 0;
3409
3410         if (!bctl)
3411                 return 0;
3412
3413         if (flags & BTRFS_BLOCK_GROUP_DATA &&
3414             bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3415                 target = BTRFS_BLOCK_GROUP_DATA | bctl->data.target;
3416         } else if (flags & BTRFS_BLOCK_GROUP_SYSTEM &&
3417                    bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3418                 target = BTRFS_BLOCK_GROUP_SYSTEM | bctl->sys.target;
3419         } else if (flags & BTRFS_BLOCK_GROUP_METADATA &&
3420                    bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3421                 target = BTRFS_BLOCK_GROUP_METADATA | bctl->meta.target;
3422         }
3423
3424         return target;
3425 }
3426
3427 /*
3428  * @flags: available profiles in extended format (see ctree.h)
3429  *
3430  * Returns reduced profile in chunk format.  If profile changing is in
3431  * progress (either running or paused) picks the target profile (if it's
3432  * already available), otherwise falls back to plain reducing.
3433  */
3434 u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags)
3435 {
3436         /*
3437          * we add in the count of missing devices because we want
3438          * to make sure that any RAID levels on a degraded FS
3439          * continue to be honored.
3440          */
3441         u64 num_devices = root->fs_info->fs_devices->rw_devices +
3442                 root->fs_info->fs_devices->missing_devices;
3443         u64 target;
3444         u64 tmp;
3445
3446         /*
3447          * see if restripe for this chunk_type is in progress, if so
3448          * try to reduce to the target profile
3449          */
3450         spin_lock(&root->fs_info->balance_lock);
3451         target = get_restripe_target(root->fs_info, flags);
3452         if (target) {
3453                 /* pick target profile only if it's already available */
3454                 if ((flags & target) & BTRFS_EXTENDED_PROFILE_MASK) {
3455                         spin_unlock(&root->fs_info->balance_lock);
3456                         return extended_to_chunk(target);
3457                 }
3458         }
3459         spin_unlock(&root->fs_info->balance_lock);
3460
3461         /* First, mask out the RAID levels which aren't possible */
3462         if (num_devices == 1)
3463                 flags &= ~(BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID0 |
3464                            BTRFS_BLOCK_GROUP_RAID5);
3465         if (num_devices < 3)
3466                 flags &= ~BTRFS_BLOCK_GROUP_RAID6;
3467         if (num_devices < 4)
3468                 flags &= ~BTRFS_BLOCK_GROUP_RAID10;
3469
3470         tmp = flags & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID0 |
3471                        BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID5 |
3472                        BTRFS_BLOCK_GROUP_RAID6 | BTRFS_BLOCK_GROUP_RAID10);
3473         flags &= ~tmp;
3474
3475         if (tmp & BTRFS_BLOCK_GROUP_RAID6)
3476                 tmp = BTRFS_BLOCK_GROUP_RAID6;
3477         else if (tmp & BTRFS_BLOCK_GROUP_RAID5)
3478                 tmp = BTRFS_BLOCK_GROUP_RAID5;
3479         else if (tmp & BTRFS_BLOCK_GROUP_RAID10)
3480                 tmp = BTRFS_BLOCK_GROUP_RAID10;
3481         else if (tmp & BTRFS_BLOCK_GROUP_RAID1)
3482                 tmp = BTRFS_BLOCK_GROUP_RAID1;
3483         else if (tmp & BTRFS_BLOCK_GROUP_RAID0)
3484                 tmp = BTRFS_BLOCK_GROUP_RAID0;
3485
3486         return extended_to_chunk(flags | tmp);
3487 }
3488
3489 static u64 get_alloc_profile(struct btrfs_root *root, u64 flags)
3490 {
3491         unsigned seq;
3492
3493         do {
3494                 seq = read_seqbegin(&root->fs_info->profiles_lock);
3495
3496                 if (flags & BTRFS_BLOCK_GROUP_DATA)
3497                         flags |= root->fs_info->avail_data_alloc_bits;
3498                 else if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
3499                         flags |= root->fs_info->avail_system_alloc_bits;
3500                 else if (flags & BTRFS_BLOCK_GROUP_METADATA)
3501                         flags |= root->fs_info->avail_metadata_alloc_bits;
3502         } while (read_seqretry(&root->fs_info->profiles_lock, seq));
3503
3504         return btrfs_reduce_alloc_profile(root, flags);
3505 }
3506
3507 u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data)
3508 {
3509         u64 flags;
3510         u64 ret;
3511
3512         if (data)
3513                 flags = BTRFS_BLOCK_GROUP_DATA;
3514         else if (root == root->fs_info->chunk_root)
3515                 flags = BTRFS_BLOCK_GROUP_SYSTEM;
3516         else
3517                 flags = BTRFS_BLOCK_GROUP_METADATA;
3518
3519         ret = get_alloc_profile(root, flags);
3520         return ret;
3521 }
3522
3523 /*
3524  * This will check the space that the inode allocates from to make sure we have
3525  * enough space for bytes.
3526  */
3527 int btrfs_check_data_free_space(struct inode *inode, u64 bytes)
3528 {
3529         struct btrfs_space_info *data_sinfo;
3530         struct btrfs_root *root = BTRFS_I(inode)->root;
3531         struct btrfs_fs_info *fs_info = root->fs_info;
3532         u64 used;
3533         int ret = 0, committed = 0, alloc_chunk = 1;
3534
3535         /* make sure bytes are sectorsize aligned */
3536         bytes = ALIGN(bytes, root->sectorsize);
3537
3538         if (root == root->fs_info->tree_root ||
3539             BTRFS_I(inode)->location.objectid == BTRFS_FREE_INO_OBJECTID) {
3540                 alloc_chunk = 0;
3541                 committed = 1;
3542         }
3543
3544         data_sinfo = fs_info->data_sinfo;
3545         if (!data_sinfo)
3546                 goto alloc;
3547
3548 again:
3549         /* make sure we have enough space to handle the data first */
3550         spin_lock(&data_sinfo->lock);
3551         used = data_sinfo->bytes_used + data_sinfo->bytes_reserved +
3552                 data_sinfo->bytes_pinned + data_sinfo->bytes_readonly +
3553                 data_sinfo->bytes_may_use;
3554
3555         if (used + bytes > data_sinfo->total_bytes) {
3556                 struct btrfs_trans_handle *trans;
3557
3558                 /*
3559                  * if we don't have enough free bytes in this space then we need
3560                  * to alloc a new chunk.
3561                  */
3562                 if (!data_sinfo->full && alloc_chunk) {
3563                         u64 alloc_target;
3564
3565                         data_sinfo->force_alloc = CHUNK_ALLOC_FORCE;
3566                         spin_unlock(&data_sinfo->lock);
3567 alloc:
3568                         alloc_target = btrfs_get_alloc_profile(root, 1);
3569                         trans = btrfs_join_transaction(root);
3570                         if (IS_ERR(trans))
3571                                 return PTR_ERR(trans);
3572
3573                         ret = do_chunk_alloc(trans, root->fs_info->extent_root,
3574                                              alloc_target,
3575                                              CHUNK_ALLOC_NO_FORCE);
3576                         btrfs_end_transaction(trans, root);
3577                         if (ret < 0) {
3578                                 if (ret != -ENOSPC)
3579                                         return ret;
3580                                 else
3581                                         goto commit_trans;
3582                         }
3583
3584                         if (!data_sinfo)
3585                                 data_sinfo = fs_info->data_sinfo;
3586
3587                         goto again;
3588                 }
3589
3590                 /*
3591                  * If we have less pinned bytes than we want to allocate then
3592                  * don't bother committing the transaction, it won't help us.
3593                  */
3594                 if (data_sinfo->bytes_pinned < bytes)
3595                         committed = 1;
3596                 spin_unlock(&data_sinfo->lock);
3597
3598                 /* commit the current transaction and try again */
3599 commit_trans:
3600                 if (!committed &&
3601                     !atomic_read(&root->fs_info->open_ioctl_trans)) {
3602                         committed = 1;
3603                         trans = btrfs_join_transaction(root);
3604                         if (IS_ERR(trans))
3605                                 return PTR_ERR(trans);
3606                         ret = btrfs_commit_transaction(trans, root);
3607                         if (ret)
3608                                 return ret;
3609                         goto again;
3610                 }
3611
3612                 return -ENOSPC;
3613         }
3614         data_sinfo->bytes_may_use += bytes;
3615         trace_btrfs_space_reservation(root->fs_info, "space_info",
3616                                       data_sinfo->flags, bytes, 1);
3617         spin_unlock(&data_sinfo->lock);
3618
3619         return 0;
3620 }
3621
3622 /*
3623  * Called if we need to clear a data reservation for this inode.
3624  */
3625 void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes)
3626 {
3627         struct btrfs_root *root = BTRFS_I(inode)->root;
3628         struct btrfs_space_info *data_sinfo;
3629
3630         /* make sure bytes are sectorsize aligned */
3631         bytes = ALIGN(bytes, root->sectorsize);
3632
3633         data_sinfo = root->fs_info->data_sinfo;
3634         spin_lock(&data_sinfo->lock);
3635         data_sinfo->bytes_may_use -= bytes;
3636         trace_btrfs_space_reservation(root->fs_info, "space_info",
3637                                       data_sinfo->flags, bytes, 0);
3638         spin_unlock(&data_sinfo->lock);
3639 }
3640
3641 static void force_metadata_allocation(struct btrfs_fs_info *info)
3642 {
3643         struct list_head *head = &info->space_info;
3644         struct btrfs_space_info *found;
3645
3646         rcu_read_lock();
3647         list_for_each_entry_rcu(found, head, list) {
3648                 if (found->flags & BTRFS_BLOCK_GROUP_METADATA)
3649                         found->force_alloc = CHUNK_ALLOC_FORCE;
3650         }
3651         rcu_read_unlock();
3652 }
3653
3654 static int should_alloc_chunk(struct btrfs_root *root,
3655                               struct btrfs_space_info *sinfo, int force)
3656 {
3657         struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
3658         u64 num_bytes = sinfo->total_bytes - sinfo->bytes_readonly;
3659         u64 num_allocated = sinfo->bytes_used + sinfo->bytes_reserved;
3660         u64 thresh;
3661
3662         if (force == CHUNK_ALLOC_FORCE)
3663                 return 1;
3664
3665         /*
3666          * We need to take into account the global rsv because for all intents
3667          * and purposes it's used space.  Don't worry about locking the
3668          * global_rsv, it doesn't change except when the transaction commits.
3669          */
3670         if (sinfo->flags & BTRFS_BLOCK_GROUP_METADATA)
3671                 num_allocated += global_rsv->size;
3672
3673         /*
3674          * in limited mode, we want to have some free space up to
3675          * about 1% of the FS size.
3676          */
3677         if (force == CHUNK_ALLOC_LIMITED) {
3678                 thresh = btrfs_super_total_bytes(root->fs_info->super_copy);
3679                 thresh = max_t(u64, 64 * 1024 * 1024,
3680                                div_factor_fine(thresh, 1));
3681
3682                 if (num_bytes - num_allocated < thresh)
3683                         return 1;
3684         }
3685
3686         if (num_allocated + 2 * 1024 * 1024 < div_factor(num_bytes, 8))
3687                 return 0;
3688         return 1;
3689 }
3690
3691 static u64 get_system_chunk_thresh(struct btrfs_root *root, u64 type)
3692 {
3693         u64 num_dev;
3694
3695         if (type & (BTRFS_BLOCK_GROUP_RAID10 |
3696                     BTRFS_BLOCK_GROUP_RAID0 |
3697                     BTRFS_BLOCK_GROUP_RAID5 |
3698                     BTRFS_BLOCK_GROUP_RAID6))
3699                 num_dev = root->fs_info->fs_devices->rw_devices;
3700         else if (type & BTRFS_BLOCK_GROUP_RAID1)
3701                 num_dev = 2;
3702         else
3703                 num_dev = 1;    /* DUP or single */
3704
3705         /* metadata for updaing devices and chunk tree */
3706         return btrfs_calc_trans_metadata_size(root, num_dev + 1);
3707 }
3708
3709 static void check_system_chunk(struct btrfs_trans_handle *trans,
3710                                struct btrfs_root *root, u64 type)
3711 {
3712         struct btrfs_space_info *info;
3713         u64 left;
3714         u64 thresh;
3715
3716         info = __find_space_info(root->fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
3717         spin_lock(&info->lock);
3718         left = info->total_bytes - info->bytes_used - info->bytes_pinned -
3719                 info->bytes_reserved - info->bytes_readonly;
3720         spin_unlock(&info->lock);
3721
3722         thresh = get_system_chunk_thresh(root, type);
3723         if (left < thresh && btrfs_test_opt(root, ENOSPC_DEBUG)) {
3724                 btrfs_info(root->fs_info, "left=%llu, need=%llu, flags=%llu",
3725                         left, thresh, type);
3726                 dump_space_info(info, 0, 0);
3727         }
3728
3729         if (left < thresh) {
3730                 u64 flags;
3731
3732                 flags = btrfs_get_alloc_profile(root->fs_info->chunk_root, 0);
3733                 btrfs_alloc_chunk(trans, root, flags);
3734         }
3735 }
3736
3737 static int do_chunk_alloc(struct btrfs_trans_handle *trans,
3738                           struct btrfs_root *extent_root, u64 flags, int force)
3739 {
3740         struct btrfs_space_info *space_info;
3741         struct btrfs_fs_info *fs_info = extent_root->fs_info;
3742         int wait_for_alloc = 0;
3743         int ret = 0;
3744
3745         /* Don't re-enter if we're already allocating a chunk */
3746         if (trans->allocating_chunk)
3747                 return -ENOSPC;
3748
3749         space_info = __find_space_info(extent_root->fs_info, flags);
3750         if (!space_info) {
3751                 ret = update_space_info(extent_root->fs_info, flags,
3752                                         0, 0, &space_info);
3753                 BUG_ON(ret); /* -ENOMEM */
3754         }
3755         BUG_ON(!space_info); /* Logic error */
3756
3757 again:
3758         spin_lock(&space_info->lock);
3759         if (force < space_info->force_alloc)
3760                 force = space_info->force_alloc;
3761         if (space_info->full) {
3762                 spin_unlock(&space_info->lock);
3763                 return 0;
3764         }
3765
3766         if (!should_alloc_chunk(extent_root, space_info, force)) {
3767                 spin_unlock(&space_info->lock);
3768                 return 0;
3769         } else if (space_info->chunk_alloc) {
3770                 wait_for_alloc = 1;
3771         } else {
3772                 space_info->chunk_alloc = 1;
3773         }
3774
3775         spin_unlock(&space_info->lock);
3776
3777         mutex_lock(&fs_info->chunk_mutex);
3778
3779         /*
3780          * The chunk_mutex is held throughout the entirety of a chunk
3781          * allocation, so once we've acquired the chunk_mutex we know that the
3782          * other guy is done and we need to recheck and see if we should
3783          * allocate.
3784          */
3785         if (wait_for_alloc) {
3786                 mutex_unlock(&fs_info->chunk_mutex);
3787                 wait_for_alloc = 0;
3788                 goto again;
3789         }
3790
3791         trans->allocating_chunk = true;
3792
3793         /*
3794          * If we have mixed data/metadata chunks we want to make sure we keep
3795          * allocating mixed chunks instead of individual chunks.
3796          */
3797         if (btrfs_mixed_space_info(space_info))
3798                 flags |= (BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA);
3799
3800         /*
3801          * if we're doing a data chunk, go ahead and make sure that
3802          * we keep a reasonable number of metadata chunks allocated in the
3803          * FS as well.
3804          */
3805         if (flags & BTRFS_BLOCK_GROUP_DATA && fs_info->metadata_ratio) {
3806                 fs_info->data_chunk_allocations++;
3807                 if (!(fs_info->data_chunk_allocations %
3808                       fs_info->metadata_ratio))
3809                         force_metadata_allocation(fs_info);
3810         }
3811
3812         /*
3813          * Check if we have enough space in SYSTEM chunk because we may need
3814          * to update devices.
3815          */
3816         check_system_chunk(trans, extent_root, flags);
3817
3818         ret = btrfs_alloc_chunk(trans, extent_root, flags);
3819         trans->allocating_chunk = false;
3820
3821         spin_lock(&space_info->lock);
3822         if (ret < 0 && ret != -ENOSPC)
3823                 goto out;
3824         if (ret)
3825                 space_info->full = 1;
3826         else
3827                 ret = 1;
3828
3829         space_info->force_alloc = CHUNK_ALLOC_NO_FORCE;
3830 out:
3831         space_info->chunk_alloc = 0;
3832         spin_unlock(&space_info->lock);
3833         mutex_unlock(&fs_info->chunk_mutex);
3834         return ret;
3835 }
3836
3837 static int can_overcommit(struct btrfs_root *root,
3838                           struct btrfs_space_info *space_info, u64 bytes,
3839                           enum btrfs_reserve_flush_enum flush)
3840 {
3841         struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
3842         u64 profile = btrfs_get_alloc_profile(root, 0);
3843         u64 rsv_size = 0;
3844         u64 avail;
3845         u64 used;
3846         u64 to_add;
3847
3848         used = space_info->bytes_used + space_info->bytes_reserved +
3849                 space_info->bytes_pinned + space_info->bytes_readonly;
3850
3851         spin_lock(&global_rsv->lock);
3852         rsv_size = global_rsv->size;
3853         spin_unlock(&global_rsv->lock);
3854
3855         /*
3856          * We only want to allow over committing if we have lots of actual space
3857          * free, but if we don't have enough space to handle the global reserve
3858          * space then we could end up having a real enospc problem when trying
3859          * to allocate a chunk or some other such important allocation.
3860          */
3861         rsv_size <<= 1;
3862         if (used + rsv_size >= space_info->total_bytes)
3863                 return 0;
3864
3865         used += space_info->bytes_may_use;
3866
3867         spin_lock(&root->fs_info->free_chunk_lock);
3868         avail = root->fs_info->free_chunk_space;
3869         spin_unlock(&root->fs_info->free_chunk_lock);
3870
3871         /*
3872          * If we have dup, raid1 or raid10 then only half of the free
3873          * space is actually useable.  For raid56, the space info used
3874          * doesn't include the parity drive, so we don't have to
3875          * change the math
3876          */
3877         if (profile & (BTRFS_BLOCK_GROUP_DUP |
3878                        BTRFS_BLOCK_GROUP_RAID1 |
3879                        BTRFS_BLOCK_GROUP_RAID10))
3880                 avail >>= 1;
3881
3882         to_add = space_info->total_bytes;
3883
3884         /*
3885          * If we aren't flushing all things, let us overcommit up to
3886          * 1/2th of the space. If we can flush, don't let us overcommit
3887          * too much, let it overcommit up to 1/8 of the space.
3888          */
3889         if (flush == BTRFS_RESERVE_FLUSH_ALL)
3890                 to_add >>= 3;
3891         else
3892                 to_add >>= 1;
3893
3894         /*
3895          * Limit the overcommit to the amount of free space we could possibly
3896          * allocate for chunks.
3897          */
3898         to_add = min(avail, to_add);
3899
3900         if (used + bytes < space_info->total_bytes + to_add)
3901                 return 1;
3902         return 0;
3903 }
3904
3905 void btrfs_writeback_inodes_sb_nr(struct btrfs_root *root,
3906                                   unsigned long nr_pages)
3907 {
3908         struct super_block *sb = root->fs_info->sb;
3909         int started;
3910
3911         /* If we can not start writeback, just sync all the delalloc file. */
3912         started = try_to_writeback_inodes_sb_nr(sb, nr_pages,
3913                                                       WB_REASON_FS_FREE_SPACE);
3914         if (!started) {
3915                 /*
3916                  * We needn't worry the filesystem going from r/w to r/o though
3917                  * we don't acquire ->s_umount mutex, because the filesystem
3918                  * should guarantee the delalloc inodes list be empty after
3919                  * the filesystem is readonly(all dirty pages are written to
3920                  * the disk).
3921                  */
3922                 btrfs_start_delalloc_inodes(root, 0);
3923                 btrfs_wait_ordered_extents(root, 0);
3924         }
3925 }
3926
3927 /*
3928  * shrink metadata reservation for delalloc
3929  */
3930 static void shrink_delalloc(struct btrfs_root *root, u64 to_reclaim, u64 orig,
3931                             bool wait_ordered)
3932 {
3933         struct btrfs_block_rsv *block_rsv;
3934         struct btrfs_space_info *space_info;
3935         struct btrfs_trans_handle *trans;
3936         u64 delalloc_bytes;
3937         u64 max_reclaim;
3938         long time_left;
3939         unsigned long nr_pages = (2 * 1024 * 1024) >> PAGE_CACHE_SHIFT;
3940         int loops = 0;
3941         enum btrfs_reserve_flush_enum flush;
3942
3943         trans = (struct btrfs_trans_handle *)current->journal_info;
3944         block_rsv = &root->fs_info->delalloc_block_rsv;
3945         space_info = block_rsv->space_info;
3946
3947         smp_mb();
3948         delalloc_bytes = percpu_counter_sum_positive(
3949                                                 &root->fs_info->delalloc_bytes);
3950         if (delalloc_bytes == 0) {
3951                 if (trans)
3952                         return;
3953                 btrfs_wait_ordered_extents(root, 0);
3954                 return;
3955         }
3956
3957         while (delalloc_bytes && loops < 3) {
3958                 max_reclaim = min(delalloc_bytes, to_reclaim);
3959                 nr_pages = max_reclaim >> PAGE_CACHE_SHIFT;
3960                 btrfs_writeback_inodes_sb_nr(root, nr_pages);
3961                 /*
3962                  * We need to wait for the async pages to actually start before
3963                  * we do anything.
3964                  */
3965                 wait_event(root->fs_info->async_submit_wait,
3966                            !atomic_read(&root->fs_info->async_delalloc_pages));
3967
3968                 if (!trans)
3969                         flush = BTRFS_RESERVE_FLUSH_ALL;
3970                 else
3971                         flush = BTRFS_RESERVE_NO_FLUSH;
3972                 spin_lock(&space_info->lock);
3973                 if (can_overcommit(root, space_info, orig, flush)) {
3974                         spin_unlock(&space_info->lock);
3975                         break;
3976                 }
3977                 spin_unlock(&space_info->lock);
3978
3979                 loops++;
3980                 if (wait_ordered && !trans) {
3981                         btrfs_wait_ordered_extents(root, 0);
3982                 } else {
3983                         time_left = schedule_timeout_killable(1);
3984                         if (time_left)
3985                                 break;
3986                 }
3987                 smp_mb();
3988                 delalloc_bytes = percpu_counter_sum_positive(
3989                                                 &root->fs_info->delalloc_bytes);
3990         }
3991 }
3992
3993 /**
3994  * maybe_commit_transaction - possibly commit the transaction if its ok to
3995  * @root - the root we're allocating for
3996  * @bytes - the number of bytes we want to reserve
3997  * @force - force the commit
3998  *
3999  * This will check to make sure that committing the transaction will actually
4000  * get us somewhere and then commit the transaction if it does.  Otherwise it
4001  * will return -ENOSPC.
4002  */
4003 static int may_commit_transaction(struct btrfs_root *root,
4004                                   struct btrfs_space_info *space_info,
4005                                   u64 bytes, int force)
4006 {
4007         struct btrfs_block_rsv *delayed_rsv = &root->fs_info->delayed_block_rsv;
4008         struct btrfs_trans_handle *trans;
4009
4010         trans = (struct btrfs_trans_handle *)current->journal_info;
4011         if (trans)
4012                 return -EAGAIN;
4013
4014         if (force)
4015                 goto commit;
4016
4017         /* See if there is enough pinned space to make this reservation */
4018         spin_lock(&space_info->lock);
4019         if (space_info->bytes_pinned >= bytes) {
4020                 spin_unlock(&space_info->lock);
4021                 goto commit;
4022         }
4023         spin_unlock(&space_info->lock);
4024
4025         /*
4026          * See if there is some space in the delayed insertion reservation for
4027          * this reservation.
4028          */
4029         if (space_info != delayed_rsv->space_info)
4030                 return -ENOSPC;
4031
4032         spin_lock(&space_info->lock);
4033         spin_lock(&delayed_rsv->lock);
4034         if (space_info->bytes_pinned + delayed_rsv->size < bytes) {
4035                 spin_unlock(&delayed_rsv->lock);
4036                 spin_unlock(&space_info->lock);
4037                 return -ENOSPC;
4038         }
4039         spin_unlock(&delayed_rsv->lock);
4040         spin_unlock(&space_info->lock);
4041
4042 commit:
4043         trans = btrfs_join_transaction(root);
4044         if (IS_ERR(trans))
4045                 return -ENOSPC;
4046
4047         return btrfs_commit_transaction(trans, root);
4048 }
4049
4050 enum flush_state {
4051         FLUSH_DELAYED_ITEMS_NR  =       1,
4052         FLUSH_DELAYED_ITEMS     =       2,
4053         FLUSH_DELALLOC          =       3,
4054         FLUSH_DELALLOC_WAIT     =       4,
4055         ALLOC_CHUNK             =       5,
4056         COMMIT_TRANS            =       6,
4057 };
4058
4059 static int flush_space(struct btrfs_root *root,
4060                        struct btrfs_space_info *space_info, u64 num_bytes,
4061                        u64 orig_bytes, int state)
4062 {
4063         struct btrfs_trans_handle *trans;
4064         int nr;
4065         int ret = 0;
4066
4067         switch (state) {
4068         case FLUSH_DELAYED_ITEMS_NR:
4069         case FLUSH_DELAYED_ITEMS:
4070                 if (state == FLUSH_DELAYED_ITEMS_NR) {
4071                         u64 bytes = btrfs_calc_trans_metadata_size(root, 1);
4072
4073                         nr = (int)div64_u64(num_bytes, bytes);
4074                         if (!nr)
4075                                 nr = 1;
4076                         nr *= 2;
4077                 } else {
4078                         nr = -1;
4079                 }
4080                 trans = btrfs_join_transaction(root);
4081                 if (IS_ERR(trans)) {
4082                         ret = PTR_ERR(trans);
4083                         break;
4084                 }
4085                 ret = btrfs_run_delayed_items_nr(trans, root, nr);
4086                 btrfs_end_transaction(trans, root);
4087                 break;
4088         case FLUSH_DELALLOC:
4089         case FLUSH_DELALLOC_WAIT:
4090                 shrink_delalloc(root, num_bytes, orig_bytes,
4091                                 state == FLUSH_DELALLOC_WAIT);
4092                 break;
4093         case ALLOC_CHUNK:
4094                 trans = btrfs_join_transaction(root);
4095                 if (IS_ERR(trans)) {
4096                         ret = PTR_ERR(trans);
4097                         break;
4098                 }
4099                 ret = do_chunk_alloc(trans, root->fs_info->extent_root,
4100                                      btrfs_get_alloc_profile(root, 0),
4101                                      CHUNK_ALLOC_NO_FORCE);
4102                 btrfs_end_transaction(trans, root);
4103                 if (ret == -ENOSPC)
4104                         ret = 0;
4105                 break;
4106         case COMMIT_TRANS:
4107                 ret = may_commit_transaction(root, space_info, orig_bytes, 0);
4108                 break;
4109         default:
4110                 ret = -ENOSPC;
4111                 break;
4112         }
4113
4114         return ret;
4115 }
4116 /**
4117  * reserve_metadata_bytes - try to reserve bytes from the block_rsv's space
4118  * @root - the root we're allocating for
4119  * @block_rsv - the block_rsv we're allocating for
4120  * @orig_bytes - the number of bytes we want
4121  * @flush - whether or not we can flush to make our reservation
4122  *
4123  * This will reserve orgi_bytes number of bytes from the space info associated
4124  * with the block_rsv.  If there is not enough space it will make an attempt to
4125  * flush out space to make room.  It will do this by flushing delalloc if
4126  * possible or committing the transaction.  If flush is 0 then no attempts to
4127  * regain reservations will be made and this will fail if there is not enough
4128  * space already.
4129  */
4130 static int reserve_metadata_bytes(struct btrfs_root *root,
4131                                   struct btrfs_block_rsv *block_rsv,
4132                                   u64 orig_bytes,
4133                                   enum btrfs_reserve_flush_enum flush)
4134 {
4135         struct btrfs_space_info *space_info = block_rsv->space_info;
4136         u64 used;
4137         u64 num_bytes = orig_bytes;
4138         int flush_state = FLUSH_DELAYED_ITEMS_NR;
4139         int ret = 0;
4140         bool flushing = false;
4141
4142 again:
4143         ret = 0;
4144         spin_lock(&space_info->lock);
4145         /*
4146          * We only want to wait if somebody other than us is flushing and we
4147          * are actually allowed to flush all things.
4148          */
4149         while (flush == BTRFS_RESERVE_FLUSH_ALL && !flushing &&
4150                space_info->flush) {
4151                 spin_unlock(&space_info->lock);
4152                 /*
4153                  * If we have a trans handle we can't wait because the flusher
4154                  * may have to commit the transaction, which would mean we would
4155                  * deadlock since we are waiting for the flusher to finish, but
4156                  * hold the current transaction open.
4157                  */
4158                 if (current->journal_info)
4159                         return -EAGAIN;
4160                 ret = wait_event_killable(space_info->wait, !space_info->flush);
4161                 /* Must have been killed, return */
4162                 if (ret)
4163                         return -EINTR;
4164
4165                 spin_lock(&space_info->lock);
4166         }
4167
4168         ret = -ENOSPC;
4169         used = space_info->bytes_used + space_info->bytes_reserved +
4170                 space_info->bytes_pinned + space_info->bytes_readonly +
4171                 space_info->bytes_may_use;
4172
4173         /*
4174          * The idea here is that we've not already over-reserved the block group
4175          * then we can go ahead and save our reservation first and then start
4176          * flushing if we need to.  Otherwise if we've already overcommitted
4177          * lets start flushing stuff first and then come back and try to make
4178          * our reservation.
4179          */
4180         if (used <= space_info->total_bytes) {
4181                 if (used + orig_bytes <= space_info->total_bytes) {
4182                         space_info->bytes_may_use += orig_bytes;
4183                         trace_btrfs_space_reservation(root->fs_info,
4184                                 "space_info", space_info->flags, orig_bytes, 1);
4185                         ret = 0;
4186                 } else {
4187                         /*
4188                          * Ok set num_bytes to orig_bytes since we aren't
4189                          * overocmmitted, this way we only try and reclaim what
4190                          * we need.
4191                          */
4192                         num_bytes = orig_bytes;
4193                 }
4194         } else {
4195                 /*
4196                  * Ok we're over committed, set num_bytes to the overcommitted
4197                  * amount plus the amount of bytes that we need for this
4198                  * reservation.
4199                  */
4200                 num_bytes = used - space_info->total_bytes +
4201                         (orig_bytes * 2);
4202         }
4203
4204         if (ret && can_overcommit(root, space_info, orig_bytes, flush)) {
4205                 space_info->bytes_may_use += orig_bytes;
4206                 trace_btrfs_space_reservation(root->fs_info, "space_info",
4207                                               space_info->flags, orig_bytes,
4208                                               1);
4209                 ret = 0;
4210         }
4211
4212         /*
4213          * Couldn't make our reservation, save our place so while we're trying
4214          * to reclaim space we can actually use it instead of somebody else
4215          * stealing it from us.
4216          *
4217          * We make the other tasks wait for the flush only when we can flush
4218          * all things.
4219          */
4220         if (ret && flush != BTRFS_RESERVE_NO_FLUSH) {
4221                 flushing = true;
4222                 space_info->flush = 1;
4223         }
4224
4225         spin_unlock(&space_info->lock);
4226
4227         if (!ret || flush == BTRFS_RESERVE_NO_FLUSH)
4228                 goto out;
4229
4230         ret = flush_space(root, space_info, num_bytes, orig_bytes,
4231                           flush_state);
4232         flush_state++;
4233
4234         /*
4235          * If we are FLUSH_LIMIT, we can not flush delalloc, or the deadlock
4236          * would happen. So skip delalloc flush.
4237          */
4238         if (flush == BTRFS_RESERVE_FLUSH_LIMIT &&
4239             (flush_state == FLUSH_DELALLOC ||
4240              flush_state == FLUSH_DELALLOC_WAIT))
4241                 flush_state = ALLOC_CHUNK;
4242
4243         if (!ret)
4244                 goto again;
4245         else if (flush == BTRFS_RESERVE_FLUSH_LIMIT &&
4246                  flush_state < COMMIT_TRANS)
4247                 goto again;
4248         else if (flush == BTRFS_RESERVE_FLUSH_ALL &&
4249                  flush_state <= COMMIT_TRANS)
4250                 goto again;
4251
4252 out:
4253         if (ret == -ENOSPC &&
4254             unlikely(root->orphan_cleanup_state == ORPHAN_CLEANUP_STARTED)) {
4255                 struct btrfs_block_rsv *global_rsv =
4256                         &root->fs_info->global_block_rsv;
4257
4258                 if (block_rsv != global_rsv &&
4259                     !block_rsv_use_bytes(global_rsv, orig_bytes))
4260                         ret = 0;
4261         }
4262         if (flushing) {
4263                 spin_lock(&space_info->lock);
4264                 space_info->flush = 0;
4265                 wake_up_all(&space_info->wait);
4266                 spin_unlock(&space_info->lock);
4267         }
4268         return ret;
4269 }
4270
4271 static struct btrfs_block_rsv *get_block_rsv(
4272                                         const struct btrfs_trans_handle *trans,
4273                                         const struct btrfs_root *root)
4274 {
4275         struct btrfs_block_rsv *block_rsv = NULL;
4276
4277         if (root->ref_cows)
4278                 block_rsv = trans->block_rsv;
4279
4280         if (root == root->fs_info->csum_root && trans->adding_csums)
4281                 block_rsv = trans->block_rsv;
4282
4283         if (!block_rsv)
4284                 block_rsv = root->block_rsv;
4285
4286         if (!block_rsv)
4287                 block_rsv = &root->fs_info->empty_block_rsv;
4288
4289         return block_rsv;
4290 }
4291
4292 static int block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv,
4293                                u64 num_bytes)
4294 {
4295         int ret = -ENOSPC;
4296         spin_lock(&block_rsv->lock);
4297         if (block_rsv->reserved >= num_bytes) {
4298                 block_rsv->reserved -= num_bytes;
4299                 if (block_rsv->reserved < block_rsv->size)
4300                         block_rsv->full = 0;
4301                 ret = 0;
4302         }
4303         spin_unlock(&block_rsv->lock);
4304         return ret;
4305 }
4306
4307 static void block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv,
4308                                 u64 num_bytes, int update_size)
4309 {
4310         spin_lock(&block_rsv->lock);
4311         block_rsv->reserved += num_bytes;
4312         if (update_size)
4313                 block_rsv->size += num_bytes;
4314         else if (block_rsv->reserved >= block_rsv->size)
4315                 block_rsv->full = 1;
4316         spin_unlock(&block_rsv->lock);
4317 }
4318
4319 static void block_rsv_release_bytes(struct btrfs_fs_info *fs_info,
4320                                     struct btrfs_block_rsv *block_rsv,
4321                                     struct btrfs_block_rsv *dest, u64 num_bytes)
4322 {
4323         struct btrfs_space_info *space_info = block_rsv->space_info;
4324
4325         spin_lock(&block_rsv->lock);
4326         if (num_bytes == (u64)-1)
4327                 num_bytes = block_rsv->size;
4328         block_rsv->size -= num_bytes;
4329         if (block_rsv->reserved >= block_rsv->size) {
4330                 num_bytes = block_rsv->reserved - block_rsv->size;
4331                 block_rsv->reserved = block_rsv->size;
4332                 block_rsv->full = 1;
4333         } else {
4334                 num_bytes = 0;
4335         }
4336         spin_unlock(&block_rsv->lock);
4337
4338         if (num_bytes > 0) {
4339                 if (dest) {
4340                         spin_lock(&dest->lock);
4341                         if (!dest->full) {
4342                                 u64 bytes_to_add;
4343
4344                                 bytes_to_add = dest->size - dest->reserved;
4345                                 bytes_to_add = min(num_bytes, bytes_to_add);
4346                                 dest->reserved += bytes_to_add;
4347                                 if (dest->reserved >= dest->size)
4348                                         dest->full = 1;
4349                                 num_bytes -= bytes_to_add;
4350                         }
4351                         spin_unlock(&dest->lock);
4352                 }
4353                 if (num_bytes) {
4354                         spin_lock(&space_info->lock);
4355                         space_info->bytes_may_use -= num_bytes;
4356                         trace_btrfs_space_reservation(fs_info, "space_info",
4357                                         space_info->flags, num_bytes, 0);
4358                         space_info->reservation_progress++;
4359                         spin_unlock(&space_info->lock);
4360                 }
4361         }
4362 }
4363
4364 static int block_rsv_migrate_bytes(struct btrfs_block_rsv *src,
4365                                    struct btrfs_block_rsv *dst, u64 num_bytes)
4366 {
4367         int ret;
4368
4369         ret = block_rsv_use_bytes(src, num_bytes);
4370         if (ret)
4371                 return ret;
4372
4373         block_rsv_add_bytes(dst, num_bytes, 1);
4374         return 0;
4375 }
4376
4377 void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type)
4378 {
4379         memset(rsv, 0, sizeof(*rsv));
4380         spin_lock_init(&rsv->lock);
4381         rsv->type = type;
4382 }
4383
4384 struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root,
4385                                               unsigned short type)
4386 {
4387         struct btrfs_block_rsv *block_rsv;
4388         struct btrfs_fs_info *fs_info = root->fs_info;
4389
4390         block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS);
4391         if (!block_rsv)
4392                 return NULL;
4393
4394         btrfs_init_block_rsv(block_rsv, type);
4395         block_rsv->space_info = __find_space_info(fs_info,
4396                                                   BTRFS_BLOCK_GROUP_METADATA);
4397         return block_rsv;
4398 }
4399
4400 void btrfs_free_block_rsv(struct btrfs_root *root,
4401                           struct btrfs_block_rsv *rsv)
4402 {
4403         if (!rsv)
4404                 return;
4405         btrfs_block_rsv_release(root, rsv, (u64)-1);
4406         kfree(rsv);
4407 }
4408
4409 int btrfs_block_rsv_add(struct btrfs_root *root,
4410                         struct btrfs_block_rsv *block_rsv, u64 num_bytes,
4411                         enum btrfs_reserve_flush_enum flush)
4412 {
4413         int ret;
4414
4415         if (num_bytes == 0)
4416                 return 0;
4417
4418         ret = reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
4419         if (!ret) {
4420                 block_rsv_add_bytes(block_rsv, num_bytes, 1);
4421                 return 0;
4422         }
4423
4424         return ret;
4425 }
4426
4427 int btrfs_block_rsv_check(struct btrfs_root *root,
4428                           struct btrfs_block_rsv *block_rsv, int min_factor)
4429 {
4430         u64 num_bytes = 0;
4431         int ret = -ENOSPC;
4432
4433         if (!block_rsv)
4434                 return 0;
4435
4436         spin_lock(&block_rsv->lock);
4437         num_bytes = div_factor(block_rsv->size, min_factor);
4438         if (block_rsv->reserved >= num_bytes)
4439                 ret = 0;
4440         spin_unlock(&block_rsv->lock);
4441
4442         return ret;
4443 }
4444
4445 int btrfs_block_rsv_refill(struct btrfs_root *root,
4446                            struct btrfs_block_rsv *block_rsv, u64 min_reserved,
4447                            enum btrfs_reserve_flush_enum flush)
4448 {
4449         u64 num_bytes = 0;
4450         int ret = -ENOSPC;
4451
4452         if (!block_rsv)
4453                 return 0;
4454
4455         spin_lock(&block_rsv->lock);
4456         num_bytes = min_reserved;
4457         if (block_rsv->reserved >= num_bytes)
4458                 ret = 0;
4459         else
4460                 num_bytes -= block_rsv->reserved;
4461         spin_unlock(&block_rsv->lock);
4462
4463         if (!ret)
4464                 return 0;
4465
4466         ret = reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
4467         if (!ret) {
4468                 block_rsv_add_bytes(block_rsv, num_bytes, 0);
4469                 return 0;
4470         }
4471
4472         return ret;
4473 }
4474
4475 int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
4476                             struct btrfs_block_rsv *dst_rsv,
4477                             u64 num_bytes)
4478 {
4479         return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
4480 }
4481
4482 void btrfs_block_rsv_release(struct btrfs_root *root,
4483                              struct btrfs_block_rsv *block_rsv,
4484                              u64 num_bytes)
4485 {
4486         struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
4487         if (global_rsv->full || global_rsv == block_rsv ||
4488             block_rsv->space_info != global_rsv->space_info)
4489                 global_rsv = NULL;
4490         block_rsv_release_bytes(root->fs_info, block_rsv, global_rsv,
4491                                 num_bytes);
4492 }
4493
4494 /*
4495  * helper to calculate size of global block reservation.
4496  * the desired value is sum of space used by extent tree,
4497  * checksum tree and root tree
4498  */
4499 static u64 calc_global_metadata_size(struct btrfs_fs_info *fs_info)
4500 {
4501         struct btrfs_space_info *sinfo;
4502         u64 num_bytes;
4503         u64 meta_used;
4504         u64 data_used;
4505         int csum_size = btrfs_super_csum_size(fs_info->super_copy);
4506
4507         sinfo = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_DATA);
4508         spin_lock(&sinfo->lock);
4509         data_used = sinfo->bytes_used;
4510         spin_unlock(&sinfo->lock);
4511
4512         sinfo = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
4513         spin_lock(&sinfo->lock);
4514         if (sinfo->flags & BTRFS_BLOCK_GROUP_DATA)
4515                 data_used = 0;
4516         meta_used = sinfo->bytes_used;
4517         spin_unlock(&sinfo->lock);
4518
4519         num_bytes = (data_used >> fs_info->sb->s_blocksize_bits) *
4520                     csum_size * 2;
4521         num_bytes += div64_u64(data_used + meta_used, 50);
4522
4523         if (num_bytes * 3 > meta_used)
4524                 num_bytes = div64_u64(meta_used, 3);
4525
4526         return ALIGN(num_bytes, fs_info->extent_root->leafsize << 10);
4527 }
4528
4529 static void update_global_block_rsv(struct btrfs_fs_info *fs_info)
4530 {
4531         struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
4532         struct btrfs_space_info *sinfo = block_rsv->space_info;
4533         u64 num_bytes;
4534
4535         num_bytes = calc_global_metadata_size(fs_info);
4536
4537         spin_lock(&sinfo->lock);
4538         spin_lock(&block_rsv->lock);
4539
4540         block_rsv->size = min_t(u64, num_bytes, 512 * 1024 * 1024);
4541
4542         num_bytes = sinfo->bytes_used + sinfo->bytes_pinned +
4543                     sinfo->bytes_reserved + sinfo->bytes_readonly +
4544                     sinfo->bytes_may_use;
4545
4546         if (sinfo->total_bytes > num_bytes) {
4547                 num_bytes = sinfo->total_bytes - num_bytes;
4548                 block_rsv->reserved += num_bytes;
4549                 sinfo->bytes_may_use += num_bytes;
4550                 trace_btrfs_space_reservation(fs_info, "space_info",
4551                                       sinfo->flags, num_bytes, 1);
4552         }
4553
4554         if (block_rsv->reserved >= block_rsv->size) {
4555                 num_bytes = block_rsv->reserved - block_rsv->size;
4556                 sinfo->bytes_may_use -= num_bytes;
4557                 trace_btrfs_space_reservation(fs_info, "space_info",
4558                                       sinfo->flags, num_bytes, 0);
4559                 sinfo->reservation_progress++;
4560                 block_rsv->reserved = block_rsv->size;
4561                 block_rsv->full = 1;
4562         }
4563
4564         spin_unlock(&block_rsv->lock);
4565         spin_unlock(&sinfo->lock);
4566 }
4567
4568 static void init_global_block_rsv(struct btrfs_fs_info *fs_info)
4569 {
4570         struct btrfs_space_info *space_info;
4571
4572         space_info = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
4573         fs_info->chunk_block_rsv.space_info = space_info;
4574
4575         space_info = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
4576         fs_info->global_block_rsv.space_info = space_info;
4577         fs_info->delalloc_block_rsv.space_info = space_info;
4578         fs_info->trans_block_rsv.space_info = space_info;
4579         fs_info->empty_block_rsv.space_info = space_info;
4580         fs_info->delayed_block_rsv.space_info = space_info;
4581
4582         fs_info->extent_root->block_rsv = &fs_info->global_block_rsv;
4583         fs_info->csum_root->block_rsv = &fs_info->global_block_rsv;
4584         fs_info->dev_root->block_rsv = &fs_info->global_block_rsv;
4585         fs_info->tree_root->block_rsv = &fs_info->global_block_rsv;
4586         fs_info->chunk_root->block_rsv = &fs_info->chunk_block_rsv;
4587
4588         update_global_block_rsv(fs_info);
4589 }
4590
4591 static void release_global_block_rsv(struct btrfs_fs_info *fs_info)
4592 {
4593         block_rsv_release_bytes(fs_info, &fs_info->global_block_rsv, NULL,
4594                                 (u64)-1);
4595         WARN_ON(fs_info->delalloc_block_rsv.size > 0);
4596         WARN_ON(fs_info->delalloc_block_rsv.reserved > 0);
4597         WARN_ON(fs_info->trans_block_rsv.size > 0);
4598         WARN_ON(fs_info->trans_block_rsv.reserved > 0);
4599         WARN_ON(fs_info->chunk_block_rsv.size > 0);
4600         WARN_ON(fs_info->chunk_block_rsv.reserved > 0);
4601         WARN_ON(fs_info->delayed_block_rsv.size > 0);
4602         WARN_ON(fs_info->delayed_block_rsv.reserved > 0);
4603 }
4604
4605 void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
4606                                   struct btrfs_root *root)
4607 {
4608         if (!trans->block_rsv)
4609                 return;
4610
4611         if (!trans->bytes_reserved)
4612                 return;
4613
4614         trace_btrfs_space_reservation(root->fs_info, "transaction",
4615                                       trans->transid, trans->bytes_reserved, 0);
4616         btrfs_block_rsv_release(root, trans->block_rsv, trans->bytes_reserved);
4617         trans->bytes_reserved = 0;
4618 }
4619
4620 /* Can only return 0 or -ENOSPC */
4621 int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
4622                                   struct inode *inode)
4623 {
4624         struct btrfs_root *root = BTRFS_I(inode)->root;
4625         struct btrfs_block_rsv *src_rsv = get_block_rsv(trans, root);
4626         struct btrfs_block_rsv *dst_rsv = root->orphan_block_rsv;
4627
4628         /*
4629          * We need to hold space in order to delete our orphan item once we've
4630          * added it, so this takes the reservation so we can release it later
4631          * when we are truly done with the orphan item.
4632          */
4633         u64 num_bytes = btrfs_calc_trans_metadata_size(root, 1);
4634         trace_btrfs_space_reservation(root->fs_info, "orphan",
4635                                       btrfs_ino(inode), num_bytes, 1);
4636         return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
4637 }
4638
4639 void btrfs_orphan_release_metadata(struct inode *inode)
4640 {
4641         struct btrfs_root *root = BTRFS_I(inode)->root;
4642         u64 num_bytes = btrfs_calc_trans_metadata_size(root, 1);
4643         trace_btrfs_space_reservation(root->fs_info, "orphan",
4644                                       btrfs_ino(inode), num_bytes, 0);
4645         btrfs_block_rsv_release(root, root->orphan_block_rsv, num_bytes);
4646 }
4647
4648 /*
4649  * btrfs_subvolume_reserve_metadata() - reserve space for subvolume operation
4650  * root: the root of the parent directory
4651  * rsv: block reservation
4652  * items: the number of items that we need do reservation
4653  * qgroup_reserved: used to return the reserved size in qgroup
4654  *
4655  * This function is used to reserve the space for snapshot/subvolume
4656  * creation and deletion. Those operations are different with the
4657  * common file/directory operations, they change two fs/file trees
4658  * and root tree, the number of items that the qgroup reserves is
4659  * different with the free space reservation. So we can not use
4660  * the space reseravtion mechanism in start_transaction().
4661  */
4662 int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
4663                                      struct btrfs_block_rsv *rsv,
4664                                      int items,
4665                                      u64 *qgroup_reserved)
4666 {
4667         u64 num_bytes;
4668         int ret;
4669
4670         if (root->fs_info->quota_enabled) {
4671                 /* One for parent inode, two for dir entries */
4672                 num_bytes = 3 * root->leafsize;
4673                 ret = btrfs_qgroup_reserve(root, num_bytes);
4674                 if (ret)
4675                         return ret;
4676         } else {
4677                 num_bytes = 0;
4678         }
4679
4680         *qgroup_reserved = num_bytes;
4681
4682         num_bytes = btrfs_calc_trans_metadata_size(root, items);
4683         rsv->space_info = __find_space_info(root->fs_info,
4684                                             BTRFS_BLOCK_GROUP_METADATA);
4685         ret = btrfs_block_rsv_add(root, rsv, num_bytes,
4686                                   BTRFS_RESERVE_FLUSH_ALL);
4687         if (ret) {
4688                 if (*qgroup_reserved)
4689                         btrfs_qgroup_free(root, *qgroup_reserved);
4690         }
4691
4692         return ret;
4693 }
4694
4695 void btrfs_subvolume_release_metadata(struct btrfs_root *root,
4696                                       struct btrfs_block_rsv *rsv,
4697                                       u64 qgroup_reserved)
4698 {
4699         btrfs_block_rsv_release(root, rsv, (u64)-1);
4700         if (qgroup_reserved)
4701                 btrfs_qgroup_free(root, qgroup_reserved);
4702 }
4703
4704 /**
4705  * drop_outstanding_extent - drop an outstanding extent
4706  * @inode: the inode we're dropping the extent for
4707  *
4708  * This is called when we are freeing up an outstanding extent, either called
4709  * after an error or after an extent is written.  This will return the number of
4710  * reserved extents that need to be freed.  This must be called with
4711  * BTRFS_I(inode)->lock held.
4712  */
4713 static unsigned drop_outstanding_extent(struct inode *inode)
4714 {
4715         unsigned drop_inode_space = 0;
4716         unsigned dropped_extents = 0;
4717
4718         BUG_ON(!BTRFS_I(inode)->outstanding_extents);
4719         BTRFS_I(inode)->outstanding_extents--;
4720
4721         if (BTRFS_I(inode)->outstanding_extents == 0 &&
4722             test_and_clear_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
4723                                &BTRFS_I(inode)->runtime_flags))
4724                 drop_inode_space = 1;
4725
4726         /*
4727          * If we have more or the same amount of outsanding extents than we have
4728          * reserved then we need to leave the reserved extents count alone.
4729          */
4730         if (BTRFS_I(inode)->outstanding_extents >=
4731             BTRFS_I(inode)->reserved_extents)
4732                 return drop_inode_space;
4733
4734         dropped_extents = BTRFS_I(inode)->reserved_extents -
4735                 BTRFS_I(inode)->outstanding_extents;
4736         BTRFS_I(inode)->reserved_extents -= dropped_extents;
4737         return dropped_extents + drop_inode_space;
4738 }
4739
4740 /**
4741  * calc_csum_metadata_size - return the amount of metada space that must be
4742  *      reserved/free'd for the given bytes.
4743  * @inode: the inode we're manipulating
4744  * @num_bytes: the number of bytes in question
4745  * @reserve: 1 if we are reserving space, 0 if we are freeing space
4746  *
4747  * This adjusts the number of csum_bytes in the inode and then returns the
4748  * correct amount of metadata that must either be reserved or freed.  We
4749  * calculate how many checksums we can fit into one leaf and then divide the
4750  * number of bytes that will need to be checksumed by this value to figure out
4751  * how many checksums will be required.  If we are adding bytes then the number
4752  * may go up and we will return the number of additional bytes that must be
4753  * reserved.  If it is going down we will return the number of bytes that must
4754  * be freed.
4755  *
4756  * This must be called with BTRFS_I(inode)->lock held.
4757  */
4758 static u64 calc_csum_metadata_size(struct inode *inode, u64 num_bytes,
4759                                    int reserve)
4760 {
4761         struct btrfs_root *root = BTRFS_I(inode)->root;
4762         u64 csum_size;
4763         int num_csums_per_leaf;
4764         int num_csums;
4765         int old_csums;
4766
4767         if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM &&
4768             BTRFS_I(inode)->csum_bytes == 0)
4769                 return 0;
4770
4771         old_csums = (int)div64_u64(BTRFS_I(inode)->csum_bytes, root->sectorsize);
4772         if (reserve)
4773                 BTRFS_I(inode)->csum_bytes += num_bytes;
4774         else
4775                 BTRFS_I(inode)->csum_bytes -= num_bytes;
4776         csum_size = BTRFS_LEAF_DATA_SIZE(root) - sizeof(struct btrfs_item);
4777         num_csums_per_leaf = (int)div64_u64(csum_size,
4778                                             sizeof(struct btrfs_csum_item) +
4779                                             sizeof(struct btrfs_disk_key));
4780         num_csums = (int)div64_u64(BTRFS_I(inode)->csum_bytes, root->sectorsize);
4781         num_csums = num_csums + num_csums_per_leaf - 1;
4782         num_csums = num_csums / num_csums_per_leaf;
4783
4784         old_csums = old_csums + num_csums_per_leaf - 1;
4785         old_csums = old_csums / num_csums_per_leaf;
4786
4787         /* No change, no need to reserve more */
4788         if (old_csums == num_csums)
4789                 return 0;
4790
4791         if (reserve)
4792                 return btrfs_calc_trans_metadata_size(root,
4793                                                       num_csums - old_csums);
4794
4795         return btrfs_calc_trans_metadata_size(root, old_csums - num_csums);
4796 }
4797
4798 int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
4799 {
4800         struct btrfs_root *root = BTRFS_I(inode)->root;
4801         struct btrfs_block_rsv *block_rsv = &root->fs_info->delalloc_block_rsv;
4802         u64 to_reserve = 0;
4803         u64 csum_bytes;
4804         unsigned nr_extents = 0;
4805         int extra_reserve = 0;
4806         enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_FLUSH_ALL;
4807         int ret = 0;
4808         bool delalloc_lock = true;
4809         u64 to_free = 0;
4810         unsigned dropped;
4811
4812         /* If we are a free space inode we need to not flush since we will be in
4813          * the middle of a transaction commit.  We also don't need the delalloc
4814          * mutex since we won't race with anybody.  We need this mostly to make
4815          * lockdep shut its filthy mouth.
4816          */
4817         if (btrfs_is_free_space_inode(inode)) {
4818                 flush = BTRFS_RESERVE_NO_FLUSH;
4819                 delalloc_lock = false;
4820         }
4821
4822         if (flush != BTRFS_RESERVE_NO_FLUSH &&
4823             btrfs_transaction_in_commit(root->fs_info))
4824                 schedule_timeout(1);
4825
4826         if (delalloc_lock)
4827                 mutex_lock(&BTRFS_I(inode)->delalloc_mutex);
4828
4829         num_bytes = ALIGN(num_bytes, root->sectorsize);
4830
4831         spin_lock(&BTRFS_I(inode)->lock);
4832         BTRFS_I(inode)->outstanding_extents++;
4833
4834         if (BTRFS_I(inode)->outstanding_extents >
4835             BTRFS_I(inode)->reserved_extents)
4836                 nr_extents = BTRFS_I(inode)->outstanding_extents -
4837                         BTRFS_I(inode)->reserved_extents;
4838
4839         /*
4840          * Add an item to reserve for updating the inode when we complete the
4841          * delalloc io.
4842          */
4843         if (!test_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
4844                       &BTRFS_I(inode)->runtime_flags)) {
4845                 nr_extents++;
4846                 extra_reserve = 1;
4847         }
4848
4849         to_reserve = btrfs_calc_trans_metadata_size(root, nr_extents);
4850         to_reserve += calc_csum_metadata_size(inode, num_bytes, 1);
4851         csum_bytes = BTRFS_I(inode)->csum_bytes;
4852         spin_unlock(&BTRFS_I(inode)->lock);
4853
4854         if (root->fs_info->quota_enabled) {
4855                 ret = btrfs_qgroup_reserve(root, num_bytes +
4856                                            nr_extents * root->leafsize);
4857                 if (ret)
4858                         goto out_fail;
4859         }
4860
4861         ret = reserve_metadata_bytes(root, block_rsv, to_reserve, flush);
4862         if (unlikely(ret)) {
4863                 if (root->fs_info->quota_enabled)
4864                         btrfs_qgroup_free(root, num_bytes +
4865                                                 nr_extents * root->leafsize);
4866                 goto out_fail;
4867         }
4868
4869         spin_lock(&BTRFS_I(inode)->lock);
4870         if (extra_reserve) {
4871                 set_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
4872                         &BTRFS_I(inode)->runtime_flags);
4873                 nr_extents--;
4874         }
4875         BTRFS_I(inode)->reserved_extents += nr_extents;
4876         spin_unlock(&BTRFS_I(inode)->lock);
4877
4878         if (delalloc_lock)
4879                 mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
4880
4881         if (to_reserve)
4882                 trace_btrfs_space_reservation(root->fs_info,"delalloc",
4883                                               btrfs_ino(inode), to_reserve, 1);
4884         block_rsv_add_bytes(block_rsv, to_reserve, 1);
4885
4886         return 0;
4887
4888 out_fail:
4889         spin_lock(&BTRFS_I(inode)->lock);
4890         dropped = drop_outstanding_extent(inode);
4891         /*
4892          * If the inodes csum_bytes is the same as the original
4893          * csum_bytes then we know we haven't raced with any free()ers
4894          * so we can just reduce our inodes csum bytes and carry on.
4895          */
4896         if (BTRFS_I(inode)->csum_bytes == csum_bytes) {
4897                 calc_csum_metadata_size(inode, num_bytes, 0);
4898         } else {
4899                 u64 orig_csum_bytes = BTRFS_I(inode)->csum_bytes;
4900                 u64 bytes;
4901
4902                 /*
4903                  * This is tricky, but first we need to figure out how much we
4904                  * free'd from any free-ers that occured during this
4905                  * reservation, so we reset ->csum_bytes to the csum_bytes
4906                  * before we dropped our lock, and then call the free for the
4907                  * number of bytes that were freed while we were trying our
4908                  * reservation.
4909                  */
4910                 bytes = csum_bytes - BTRFS_I(inode)->csum_bytes;
4911                 BTRFS_I(inode)->csum_bytes = csum_bytes;
4912                 to_free = calc_csum_metadata_size(inode, bytes, 0);
4913
4914
4915                 /*
4916                  * Now we need to see how much we would have freed had we not
4917                  * been making this reservation and our ->csum_bytes were not
4918                  * artificially inflated.
4919                  */
4920                 BTRFS_I(inode)->csum_bytes = csum_bytes - num_bytes;
4921                 bytes = csum_bytes - orig_csum_bytes;
4922                 bytes = calc_csum_metadata_size(inode, bytes, 0);
4923
4924                 /*
4925                  * Now reset ->csum_bytes to what it should be.  If bytes is
4926                  * more than to_free then we would have free'd more space had we
4927                  * not had an artificially high ->csum_bytes, so we need to free
4928                  * the remainder.  If bytes is the same or less then we don't
4929                  * need to do anything, the other free-ers did the correct
4930                  * thing.
4931                  */
4932                 BTRFS_I(inode)->csum_bytes = orig_csum_bytes - num_bytes;
4933                 if (bytes > to_free)
4934                         to_free = bytes - to_free;
4935                 else
4936                         to_free = 0;
4937         }
4938         spin_unlock(&BTRFS_I(inode)->lock);
4939         if (dropped)
4940                 to_free += btrfs_calc_trans_metadata_size(root, dropped);
4941
4942         if (to_free) {
4943                 btrfs_block_rsv_release(root, block_rsv, to_free);
4944                 trace_btrfs_space_reservation(root->fs_info, "delalloc",
4945                                               btrfs_ino(inode), to_free, 0);
4946         }
4947         if (delalloc_lock)
4948                 mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
4949         return ret;
4950 }
4951
4952 /**
4953  * btrfs_delalloc_release_metadata - release a metadata reservation for an inode
4954  * @inode: the inode to release the reservation for
4955  * @num_bytes: the number of bytes we're releasing
4956  *
4957  * This will release the metadata reservation for an inode.  This can be called
4958  * once we complete IO for a given set of bytes to release their metadata
4959  * reservations.
4960  */
4961 void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes)
4962 {
4963         struct btrfs_root *root = BTRFS_I(inode)->root;
4964         u64 to_free = 0;
4965         unsigned dropped;
4966
4967         num_bytes = ALIGN(num_bytes, root->sectorsize);
4968         spin_lock(&BTRFS_I(inode)->lock);
4969         dropped = drop_outstanding_extent(inode);
4970
4971         if (num_bytes)
4972                 to_free = calc_csum_metadata_size(inode, num_bytes, 0);
4973         spin_unlock(&BTRFS_I(inode)->lock);
4974         if (dropped > 0)
4975                 to_free += btrfs_calc_trans_metadata_size(root, dropped);
4976
4977         trace_btrfs_space_reservation(root->fs_info, "delalloc",
4978                                       btrfs_ino(inode), to_free, 0);
4979         if (root->fs_info->quota_enabled) {
4980                 btrfs_qgroup_free(root, num_bytes +
4981                                         dropped * root->leafsize);
4982         }
4983
4984         btrfs_block_rsv_release(root, &root->fs_info->delalloc_block_rsv,
4985                                 to_free);
4986 }
4987
4988 /**
4989  * btrfs_delalloc_reserve_space - reserve data and metadata space for delalloc
4990  * @inode: inode we're writing to
4991  * @num_bytes: the number of bytes we want to allocate
4992  *
4993  * This will do the following things
4994  *
4995  * o reserve space in the data space info for num_bytes
4996  * o reserve space in the metadata space info based on number of outstanding
4997  *   extents and how much csums will be needed
4998  * o add to the inodes ->delalloc_bytes
4999  * o add it to the fs_info's delalloc inodes list.
5000  *
5001  * This will return 0 for success and -ENOSPC if there is no space left.
5002  */
5003 int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes)
5004 {
5005         int ret;
5006
5007         ret = btrfs_check_data_free_space(inode, num_bytes);
5008         if (ret)
5009                 return ret;
5010
5011         ret = btrfs_delalloc_reserve_metadata(inode, num_bytes);
5012         if (ret) {
5013                 btrfs_free_reserved_data_space(inode, num_bytes);
5014                 return ret;
5015         }
5016
5017         return 0;
5018 }
5019
5020 /**
5021  * btrfs_delalloc_release_space - release data and metadata space for delalloc
5022  * @inode: inode we're releasing space for
5023  * @num_bytes: the number of bytes we want to free up
5024  *
5025  * This must be matched with a call to btrfs_delalloc_reserve_space.  This is
5026  * called in the case that we don't need the metadata AND data reservations
5027  * anymore.  So if there is an error or we insert an inline extent.
5028  *
5029  * This function will release the metadata space that was not used and will
5030  * decrement ->delalloc_bytes and remove it from the fs_info delalloc_inodes
5031  * list if there are no delalloc bytes left.
5032  */
5033 void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes)
5034 {
5035         btrfs_delalloc_release_metadata(inode, num_bytes);
5036         btrfs_free_reserved_data_space(inode, num_bytes);
5037 }
5038
5039 static int update_block_group(struct btrfs_root *root,
5040                               u64 bytenr, u64 num_bytes, int alloc)
5041 {
5042         struct btrfs_block_group_cache *cache = NULL;
5043         struct btrfs_fs_info *info = root->fs_info;
5044         u64 total = num_bytes;
5045         u64 old_val;
5046         u64 byte_in_group;
5047         int factor;
5048
5049         /* block accounting for super block */
5050         spin_lock(&info->delalloc_lock);
5051         old_val = btrfs_super_bytes_used(info->super_copy);
5052         if (alloc)
5053                 old_val += num_bytes;
5054         else
5055                 old_val -= num_bytes;
5056         btrfs_set_super_bytes_used(info->super_copy, old_val);
5057         spin_unlock(&info->delalloc_lock);
5058
5059         while (total) {
5060                 cache = btrfs_lookup_block_group(info, bytenr);
5061                 if (!cache)
5062                         return -ENOENT;
5063                 if (cache->flags & (BTRFS_BLOCK_GROUP_DUP |
5064                                     BTRFS_BLOCK_GROUP_RAID1 |
5065                                     BTRFS_BLOCK_GROUP_RAID10))
5066                         factor = 2;
5067                 else
5068                         factor = 1;
5069                 /*
5070                  * If this block group has free space cache written out, we
5071                  * need to make sure to load it if we are removing space.  This
5072                  * is because we need the unpinning stage to actually add the
5073                  * space back to the block group, otherwise we will leak space.
5074                  */
5075                 if (!alloc && cache->cached == BTRFS_CACHE_NO)
5076                         cache_block_group(cache, 1);
5077
5078                 byte_in_group = bytenr - cache->key.objectid;
5079                 WARN_ON(byte_in_group > cache->key.offset);
5080
5081                 spin_lock(&cache->space_info->lock);
5082                 spin_lock(&cache->lock);
5083
5084                 if (btrfs_test_opt(root, SPACE_CACHE) &&
5085                     cache->disk_cache_state < BTRFS_DC_CLEAR)
5086                         cache->disk_cache_state = BTRFS_DC_CLEAR;
5087
5088                 cache->dirty = 1;
5089                 old_val = btrfs_block_group_used(&cache->item);
5090                 num_bytes = min(total, cache->key.offset - byte_in_group);
5091                 if (alloc) {
5092                         old_val += num_bytes;
5093                         btrfs_set_block_group_used(&cache->item, old_val);
5094                         cache->reserved -= num_bytes;
5095                         cache->space_info->bytes_reserved -= num_bytes;
5096                         cache->space_info->bytes_used += num_bytes;
5097                         cache->space_info->disk_used += num_bytes * factor;
5098                         spin_unlock(&cache->lock);
5099                         spin_unlock(&cache->space_info->lock);
5100                 } else {
5101                         old_val -= num_bytes;
5102                         btrfs_set_block_group_used(&cache->item, old_val);
5103                         cache->pinned += num_bytes;
5104                         cache->space_info->bytes_pinned += num_bytes;
5105                         cache->space_info->bytes_used -= num_bytes;
5106                         cache->space_info->disk_used -= num_bytes * factor;
5107                         spin_unlock(&cache->lock);
5108                         spin_unlock(&cache->space_info->lock);
5109
5110                         set_extent_dirty(info->pinned_extents,
5111                                          bytenr, bytenr + num_bytes - 1,
5112                                          GFP_NOFS | __GFP_NOFAIL);
5113                 }
5114                 btrfs_put_block_group(cache);
5115                 total -= num_bytes;
5116                 bytenr += num_bytes;
5117         }
5118         return 0;
5119 }
5120
5121 static u64 first_logical_byte(struct btrfs_root *root, u64 search_start)
5122 {
5123         struct btrfs_block_group_cache *cache;
5124         u64 bytenr;
5125
5126         spin_lock(&root->fs_info->block_group_cache_lock);
5127         bytenr = root->fs_info->first_logical_byte;
5128         spin_unlock(&root->fs_info->block_group_cache_lock);
5129
5130         if (bytenr < (u64)-1)
5131                 return bytenr;
5132
5133         cache = btrfs_lookup_first_block_group(root->fs_info, search_start);
5134         if (!cache)
5135                 return 0;
5136
5137         bytenr = cache->key.objectid;
5138         btrfs_put_block_group(cache);
5139
5140         return bytenr;
5141 }
5142
5143 static int pin_down_extent(struct btrfs_root *root,
5144                            struct btrfs_block_group_cache *cache,
5145                            u64 bytenr, u64 num_bytes, int reserved)
5146 {
5147         spin_lock(&cache->space_info->lock);
5148         spin_lock(&cache->lock);
5149         cache->pinned += num_bytes;
5150         cache->space_info->bytes_pinned += num_bytes;
5151         if (reserved) {
5152                 cache->reserved -= num_bytes;
5153                 cache->space_info->bytes_reserved -= num_bytes;
5154         }
5155         spin_unlock(&cache->lock);
5156         spin_unlock(&cache->space_info->lock);
5157
5158         set_extent_dirty(root->fs_info->pinned_extents, bytenr,
5159                          bytenr + num_bytes - 1, GFP_NOFS | __GFP_NOFAIL);
5160         return 0;
5161 }
5162
5163 /*
5164  * this function must be called within transaction
5165  */
5166 int btrfs_pin_extent(struct btrfs_root *root,
5167                      u64 bytenr, u64 num_bytes, int reserved)
5168 {
5169         struct btrfs_block_group_cache *cache;
5170
5171         cache = btrfs_lookup_block_group(root->fs_info, bytenr);
5172         BUG_ON(!cache); /* Logic error */
5173
5174         pin_down_extent(root, cache, bytenr, num_bytes, reserved);
5175
5176         btrfs_put_block_group(cache);
5177         return 0;
5178 }
5179
5180 /*
5181  * this function must be called within transaction
5182  */
5183 int btrfs_pin_extent_for_log_replay(struct btrfs_root *root,
5184                                     u64 bytenr, u64 num_bytes)
5185 {
5186         struct btrfs_block_group_cache *cache;
5187
5188         cache = btrfs_lookup_block_group(root->fs_info, bytenr);
5189         BUG_ON(!cache); /* Logic error */
5190
5191         /*
5192          * pull in the free space cache (if any) so that our pin
5193          * removes the free space from the cache.  We have load_only set
5194          * to one because the slow code to read in the free extents does check
5195          * the pinned extents.
5196          */
5197         cache_block_group(cache, 1);
5198
5199         pin_down_extent(root, cache, bytenr, num_bytes, 0);
5200
5201         /* remove us from the free space cache (if we're there at all) */
5202         btrfs_remove_free_space(cache, bytenr, num_bytes);
5203         btrfs_put_block_group(cache);
5204         return 0;
5205 }
5206
5207 /**
5208  * btrfs_update_reserved_bytes - update the block_group and space info counters
5209  * @cache:      The cache we are manipulating
5210  * @num_bytes:  The number of bytes in question
5211  * @reserve:    One of the reservation enums
5212  *
5213  * This is called by the allocator when it reserves space, or by somebody who is
5214  * freeing space that was never actually used on disk.  For example if you
5215  * reserve some space for a new leaf in transaction A and before transaction A
5216  * commits you free that leaf, you call this with reserve set to 0 in order to
5217  * clear the reservation.
5218  *
5219  * Metadata reservations should be called with RESERVE_ALLOC so we do the proper
5220  * ENOSPC accounting.  For data we handle the reservation through clearing the
5221  * delalloc bits in the io_tree.  We have to do this since we could end up
5222  * allocating less disk space for the amount of data we have reserved in the
5223  * case of compression.
5224  *
5225  * If this is a reservation and the block group has become read only we cannot
5226  * make the reservation and return -EAGAIN, otherwise this function always
5227  * succeeds.
5228  */
5229 static int btrfs_update_reserved_bytes(struct btrfs_block_group_cache *cache,
5230                                        u64 num_bytes, int reserve)
5231 {
5232         struct btrfs_space_info *space_info = cache->space_info;
5233         int ret = 0;
5234
5235         spin_lock(&space_info->lock);
5236         spin_lock(&cache->lock);
5237         if (reserve != RESERVE_FREE) {
5238                 if (cache->ro) {
5239                         ret = -EAGAIN;
5240                 } else {
5241                         cache->reserved += num_bytes;
5242                         space_info->bytes_reserved += num_bytes;
5243                         if (reserve == RESERVE_ALLOC) {
5244                                 trace_btrfs_space_reservation(cache->fs_info,
5245                                                 "space_info", space_info->flags,
5246                                                 num_bytes, 0);
5247                                 space_info->bytes_may_use -= num_bytes;
5248                         }
5249                 }
5250         } else {
5251                 if (cache->ro)
5252                         space_info->bytes_readonly += num_bytes;
5253                 cache->reserved -= num_bytes;
5254                 space_info->bytes_reserved -= num_bytes;
5255                 space_info->reservation_progress++;
5256         }
5257         spin_unlock(&cache->lock);
5258         spin_unlock(&space_info->lock);
5259         return ret;
5260 }
5261
5262 void btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
5263                                 struct btrfs_root *root)
5264 {
5265         struct btrfs_fs_info *fs_info = root->fs_info;
5266         struct btrfs_caching_control *next;
5267         struct btrfs_caching_control *caching_ctl;
5268         struct btrfs_block_group_cache *cache;
5269
5270         down_write(&fs_info->extent_commit_sem);
5271
5272         list_for_each_entry_safe(caching_ctl, next,
5273                                  &fs_info->caching_block_groups, list) {
5274                 cache = caching_ctl->block_group;
5275                 if (block_group_cache_done(cache)) {
5276                         cache->last_byte_to_unpin = (u64)-1;
5277                         list_del_init(&caching_ctl->list);
5278                         put_caching_control(caching_ctl);
5279                 } else {
5280                         cache->last_byte_to_unpin = caching_ctl->progress;
5281                 }
5282         }
5283
5284         if (fs_info->pinned_extents == &fs_info->freed_extents[0])
5285                 fs_info->pinned_extents = &fs_info->freed_extents[1];
5286         else
5287                 fs_info->pinned_extents = &fs_info->freed_extents[0];
5288
5289         up_write(&fs_info->extent_commit_sem);
5290
5291         update_global_block_rsv(fs_info);
5292 }
5293
5294 static int unpin_extent_range(struct btrfs_root *root, u64 start, u64 end)
5295 {
5296         struct btrfs_fs_info *fs_info = root->fs_info;
5297         struct btrfs_block_group_cache *cache = NULL;
5298         struct btrfs_space_info *space_info;
5299         struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
5300         u64 len;
5301         bool readonly;
5302
5303         while (start <= end) {
5304                 readonly = false;
5305                 if (!cache ||
5306                     start >= cache->key.objectid + cache->key.offset) {
5307                         if (cache)
5308                                 btrfs_put_block_group(cache);
5309                         cache = btrfs_lookup_block_group(fs_info, start);
5310                         BUG_ON(!cache); /* Logic error */
5311                 }
5312
5313                 len = cache->key.objectid + cache->key.offset - start;
5314                 len = min(len, end + 1 - start);
5315
5316                 if (start < cache->last_byte_to_unpin) {
5317                         len = min(len, cache->last_byte_to_unpin - start);
5318                         btrfs_add_free_space(cache, start, len);
5319                 }
5320
5321                 start += len;
5322                 space_info = cache->space_info;
5323
5324                 spin_lock(&space_info->lock);
5325                 spin_lock(&cache->lock);
5326                 cache->pinned -= len;
5327                 space_info->bytes_pinned -= len;
5328                 if (cache->ro) {
5329                         space_info->bytes_readonly += len;
5330                         readonly = true;
5331                 }
5332                 spin_unlock(&cache->lock);
5333                 if (!readonly && global_rsv->space_info == space_info) {
5334                         spin_lock(&global_rsv->lock);
5335                         if (!global_rsv->full) {
5336                                 len = min(len, global_rsv->size -
5337                                           global_rsv->reserved);
5338                                 global_rsv->reserved += len;
5339                                 space_info->bytes_may_use += len;
5340                                 if (global_rsv->reserved >= global_rsv->size)
5341                                         global_rsv->full = 1;
5342                         }
5343                         spin_unlock(&global_rsv->lock);
5344                 }
5345                 spin_unlock(&space_info->lock);
5346         }
5347
5348         if (cache)
5349                 btrfs_put_block_group(cache);
5350         return 0;
5351 }
5352
5353 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
5354                                struct btrfs_root *root)
5355 {
5356         struct btrfs_fs_info *fs_info = root->fs_info;
5357         struct extent_io_tree *unpin;
5358         u64 start;
5359         u64 end;
5360         int ret;
5361
5362         if (trans->aborted)
5363                 return 0;
5364
5365         if (fs_info->pinned_extents == &fs_info->freed_extents[0])
5366                 unpin = &fs_info->freed_extents[1];
5367         else
5368                 unpin = &fs_info->freed_extents[0];
5369
5370         while (1) {
5371                 ret = find_first_extent_bit(unpin, 0, &start, &end,
5372                                             EXTENT_DIRTY, NULL);
5373                 if (ret)
5374                         break;
5375
5376                 if (btrfs_test_opt(root, DISCARD))
5377                         ret = btrfs_discard_extent(root, start,
5378                                                    end + 1 - start, NULL);
5379
5380                 clear_extent_dirty(unpin, start, end, GFP_NOFS);
5381                 unpin_extent_range(root, start, end);
5382                 cond_resched();
5383         }
5384
5385         return 0;
5386 }
5387
5388 static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
5389                                 struct btrfs_root *root,
5390                                 u64 bytenr, u64 num_bytes, u64 parent,
5391                                 u64 root_objectid, u64 owner_objectid,
5392                                 u64 owner_offset, int refs_to_drop,
5393                                 struct btrfs_delayed_extent_op *extent_op)
5394 {
5395         struct btrfs_key key;
5396         struct btrfs_path *path;
5397         struct btrfs_fs_info *info = root->fs_info;
5398         struct btrfs_root *extent_root = info->extent_root;
5399         struct extent_buffer *leaf;
5400         struct btrfs_extent_item *ei;
5401         struct btrfs_extent_inline_ref *iref;
5402         int ret;
5403         int is_data;
5404         int extent_slot = 0;
5405         int found_extent = 0;
5406         int num_to_del = 1;
5407         u32 item_size;
5408         u64 refs;
5409         bool skinny_metadata = btrfs_fs_incompat(root->fs_info,
5410                                                  SKINNY_METADATA);
5411
5412         path = btrfs_alloc_path();
5413         if (!path)
5414                 return -ENOMEM;
5415
5416         path->reada = 1;
5417         path->leave_spinning = 1;
5418
5419         is_data = owner_objectid >= BTRFS_FIRST_FREE_OBJECTID;
5420         BUG_ON(!is_data && refs_to_drop != 1);
5421
5422         if (is_data)
5423                 skinny_metadata = 0;
5424
5425         ret = lookup_extent_backref(trans, extent_root, path, &iref,
5426                                     bytenr, num_bytes, parent,
5427                                     root_objectid, owner_objectid,
5428                                     owner_offset);
5429         if (ret == 0) {
5430                 extent_slot = path->slots[0];
5431                 while (extent_slot >= 0) {
5432                         btrfs_item_key_to_cpu(path->nodes[0], &key,
5433                                               extent_slot);
5434                         if (key.objectid != bytenr)
5435                                 break;
5436                         if (key.type == BTRFS_EXTENT_ITEM_KEY &&
5437                             key.offset == num_bytes) {
5438                                 found_extent = 1;
5439                                 break;
5440                         }
5441                         if (key.type == BTRFS_METADATA_ITEM_KEY &&
5442                             key.offset == owner_objectid) {
5443                                 found_extent = 1;
5444                                 break;
5445                         }
5446                         if (path->slots[0] - extent_slot > 5)
5447                                 break;
5448                         extent_slot--;
5449                 }
5450 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
5451                 item_size = btrfs_item_size_nr(path->nodes[0], extent_slot);
5452                 if (found_extent && item_size < sizeof(*ei))
5453                         found_extent = 0;
5454 #endif
5455                 if (!found_extent) {
5456                         BUG_ON(iref);
5457                         ret = remove_extent_backref(trans, extent_root, path,
5458                                                     NULL, refs_to_drop,
5459                                                     is_data);
5460                         if (ret) {
5461                                 btrfs_abort_transaction(trans, extent_root, ret);
5462                                 goto out;
5463                         }
5464                         btrfs_release_path(path);
5465                         path->leave_spinning = 1;
5466
5467                         key.objectid = bytenr;
5468                         key.type = BTRFS_EXTENT_ITEM_KEY;
5469                         key.offset = num_bytes;
5470
5471                         if (!is_data && skinny_metadata) {
5472                                 key.type = BTRFS_METADATA_ITEM_KEY;
5473                                 key.offset = owner_objectid;
5474                         }
5475
5476                         ret = btrfs_search_slot(trans, extent_root,
5477                                                 &key, path, -1, 1);
5478                         if (ret > 0 && skinny_metadata && path->slots[0]) {
5479                                 /*
5480                                  * Couldn't find our skinny metadata item,
5481                                  * see if we have ye olde extent item.
5482                                  */
5483                                 path->slots[0]--;
5484                                 btrfs_item_key_to_cpu(path->nodes[0], &key,
5485                                                       path->slots[0]);
5486                                 if (key.objectid == bytenr &&
5487                                     key.type == BTRFS_EXTENT_ITEM_KEY &&
5488                                     key.offset == num_bytes)
5489                                         ret = 0;
5490                         }
5491
5492                         if (ret > 0 && skinny_metadata) {
5493                                 skinny_metadata = false;
5494                                 key.type = BTRFS_EXTENT_ITEM_KEY;
5495                                 key.offset = num_bytes;
5496                                 btrfs_release_path(path);
5497                                 ret = btrfs_search_slot(trans, extent_root,
5498                                                         &key, path, -1, 1);
5499                         }
5500
5501                         if (ret) {
5502                                 btrfs_err(info, "umm, got %d back from search, was looking for %llu",
5503                                         ret, (unsigned long long)bytenr);
5504                                 if (ret > 0)
5505                                         btrfs_print_leaf(extent_root,
5506                                                          path->nodes[0]);
5507                         }
5508                         if (ret < 0) {
5509                                 btrfs_abort_transaction(trans, extent_root, ret);
5510                                 goto out;
5511                         }
5512                         extent_slot = path->slots[0];
5513                 }
5514         } else if (ret == -ENOENT) {
5515                 btrfs_print_leaf(extent_root, path->nodes[0]);
5516                 WARN_ON(1);
5517                 btrfs_err(info,
5518                         "unable to find ref byte nr %llu parent %llu root %llu  owner %llu offset %llu",
5519                         (unsigned long long)bytenr,
5520                         (unsigned long long)parent,
5521                         (unsigned long long)root_objectid,
5522                         (unsigned long long)owner_objectid,
5523                         (unsigned long long)owner_offset);
5524         } else {
5525                 btrfs_abort_transaction(trans, extent_root, ret);
5526                 goto out;
5527         }
5528
5529         leaf = path->nodes[0];
5530         item_size = btrfs_item_size_nr(leaf, extent_slot);
5531 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
5532         if (item_size < sizeof(*ei)) {
5533                 BUG_ON(found_extent || extent_slot != path->slots[0]);
5534                 ret = convert_extent_item_v0(trans, extent_root, path,
5535                                              owner_objectid, 0);
5536                 if (ret < 0) {
5537                         btrfs_abort_transaction(trans, extent_root, ret);
5538                         goto out;
5539                 }
5540
5541                 btrfs_release_path(path);
5542                 path->leave_spinning = 1;
5543
5544                 key.objectid = bytenr;
5545                 key.type = BTRFS_EXTENT_ITEM_KEY;
5546                 key.offset = num_bytes;
5547
5548                 ret = btrfs_search_slot(trans, extent_root, &key, path,
5549                                         -1, 1);
5550                 if (ret) {
5551                         btrfs_err(info, "umm, got %d back from search, was looking for %llu",
5552                                 ret, (unsigned long long)bytenr);
5553                         btrfs_print_leaf(extent_root, path->nodes[0]);
5554                 }
5555                 if (ret < 0) {
5556                         btrfs_abort_transaction(trans, extent_root, ret);
5557                         goto out;
5558                 }
5559
5560                 extent_slot = path->slots[0];
5561                 leaf = path->nodes[0];
5562                 item_size = btrfs_item_size_nr(leaf, extent_slot);
5563         }
5564 #endif
5565         BUG_ON(item_size < sizeof(*ei));
5566         ei = btrfs_item_ptr(leaf, extent_slot,
5567                             struct btrfs_extent_item);
5568         if (owner_objectid < BTRFS_FIRST_FREE_OBJECTID &&
5569             key.type == BTRFS_EXTENT_ITEM_KEY) {
5570                 struct btrfs_tree_block_info *bi;
5571                 BUG_ON(item_size < sizeof(*ei) + sizeof(*bi));
5572                 bi = (struct btrfs_tree_block_info *)(ei + 1);
5573                 WARN_ON(owner_objectid != btrfs_tree_block_level(leaf, bi));
5574         }
5575
5576         refs = btrfs_extent_refs(leaf, ei);
5577         BUG_ON(refs < refs_to_drop);
5578         refs -= refs_to_drop;
5579
5580         if (refs > 0) {
5581                 if (extent_op)
5582                         __run_delayed_extent_op(extent_op, leaf, ei);
5583                 /*
5584                  * In the case of inline back ref, reference count will
5585                  * be updated by remove_extent_backref
5586                  */
5587                 if (iref) {
5588                         BUG_ON(!found_extent);
5589                 } else {
5590                         btrfs_set_extent_refs(leaf, ei, refs);
5591                         btrfs_mark_buffer_dirty(leaf);
5592                 }
5593                 if (found_extent) {
5594                         ret = remove_extent_backref(trans, extent_root, path,
5595                                                     iref, refs_to_drop,
5596                                                     is_data);
5597                         if (ret) {
5598                                 btrfs_abort_transaction(trans, extent_root, ret);
5599                                 goto out;
5600                         }
5601                 }
5602         } else {
5603                 if (found_extent) {
5604                         BUG_ON(is_data && refs_to_drop !=
5605                                extent_data_ref_count(root, path, iref));
5606                         if (iref) {
5607                                 BUG_ON(path->slots[0] != extent_slot);
5608                         } else {
5609                                 BUG_ON(path->slots[0] != extent_slot + 1);
5610                                 path->slots[0] = extent_slot;
5611                                 num_to_del = 2;
5612                         }
5613                 }
5614
5615                 ret = btrfs_del_items(trans, extent_root, path, path->slots[0],
5616                                       num_to_del);
5617                 if (ret) {
5618                         btrfs_abort_transaction(trans, extent_root, ret);
5619                         goto out;
5620                 }
5621                 btrfs_release_path(path);
5622
5623                 if (is_data) {
5624                         ret = btrfs_del_csums(trans, root, bytenr, num_bytes);
5625                         if (ret) {
5626                                 btrfs_abort_transaction(trans, extent_root, ret);
5627                                 goto out;
5628                         }
5629                 }
5630
5631                 ret = update_block_group(root, bytenr, num_bytes, 0);
5632                 if (ret) {
5633                         btrfs_abort_transaction(trans, extent_root, ret);
5634                         goto out;
5635                 }
5636         }
5637 out:
5638         btrfs_free_path(path);
5639         return ret;
5640 }
5641
5642 /*
5643  * when we free an block, it is possible (and likely) that we free the last
5644  * delayed ref for that extent as well.  This searches the delayed ref tree for
5645  * a given extent, and if there are no other delayed refs to be processed, it
5646  * removes it from the tree.
5647  */
5648 static noinline int check_ref_cleanup(struct btrfs_trans_handle *trans,
5649                                       struct btrfs_root *root, u64 bytenr)
5650 {
5651         struct btrfs_delayed_ref_head *head;
5652         struct btrfs_delayed_ref_root *delayed_refs;
5653         struct btrfs_delayed_ref_node *ref;
5654         struct rb_node *node;
5655         int ret = 0;
5656
5657         delayed_refs = &trans->transaction->delayed_refs;
5658         spin_lock(&delayed_refs->lock);
5659         head = btrfs_find_delayed_ref_head(trans, bytenr);
5660         if (!head)
5661                 goto out;
5662
5663         node = rb_prev(&head->node.rb_node);
5664         if (!node)
5665                 goto out;
5666
5667         ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
5668
5669         /* there are still entries for this ref, we can't drop it */
5670         if (ref->bytenr == bytenr)
5671                 goto out;
5672
5673         if (head->extent_op) {
5674                 if (!head->must_insert_reserved)
5675                         goto out;
5676                 btrfs_free_delayed_extent_op(head->extent_op);
5677                 head->extent_op = NULL;
5678         }
5679
5680         /*
5681          * waiting for the lock here would deadlock.  If someone else has it
5682          * locked they are already in the process of dropping it anyway
5683          */
5684         if (!mutex_trylock(&head->mutex))
5685                 goto out;
5686
5687         /*
5688          * at this point we have a head with no other entries.  Go
5689          * ahead and process it.
5690          */
5691         head->node.in_tree = 0;
5692         rb_erase(&head->node.rb_node, &delayed_refs->root);
5693
5694         delayed_refs->num_entries--;
5695
5696         /*
5697          * we don't take a ref on the node because we're removing it from the
5698          * tree, so we just steal the ref the tree was holding.
5699          */
5700         delayed_refs->num_heads--;
5701         if (list_empty(&head->cluster))
5702                 delayed_refs->num_heads_ready--;
5703
5704         list_del_init(&head->cluster);
5705         spin_unlock(&delayed_refs->lock);
5706
5707         BUG_ON(head->extent_op);
5708         if (head->must_insert_reserved)
5709                 ret = 1;
5710
5711         mutex_unlock(&head->mutex);
5712         btrfs_put_delayed_ref(&head->node);
5713         return ret;
5714 out:
5715         spin_unlock(&delayed_refs->lock);
5716         return 0;
5717 }
5718
5719 void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
5720                            struct btrfs_root *root,
5721                            struct extent_buffer *buf,
5722                            u64 parent, int last_ref)
5723 {
5724         struct btrfs_block_group_cache *cache = NULL;
5725         int ret;
5726
5727         if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
5728                 ret = btrfs_add_delayed_tree_ref(root->fs_info, trans,
5729                                         buf->start, buf->len,
5730                                         parent, root->root_key.objectid,
5731                                         btrfs_header_level(buf),
5732                                         BTRFS_DROP_DELAYED_REF, NULL, 0);
5733                 BUG_ON(ret); /* -ENOMEM */
5734         }
5735
5736         if (!last_ref)
5737                 return;
5738
5739         cache = btrfs_lookup_block_group(root->fs_info, buf->start);
5740
5741         if (btrfs_header_generation(buf) == trans->transid) {
5742                 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
5743                         ret = check_ref_cleanup(trans, root, buf->start);
5744                         if (!ret)
5745                                 goto out;
5746                 }
5747
5748                 if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_WRITTEN)) {
5749                         pin_down_extent(root, cache, buf->start, buf->len, 1);
5750                         goto out;
5751                 }
5752
5753                 WARN_ON(test_bit(EXTENT_BUFFER_DIRTY, &buf->bflags));
5754
5755                 btrfs_add_free_space(cache, buf->start, buf->len);
5756                 btrfs_update_reserved_bytes(cache, buf->len, RESERVE_FREE);
5757         }
5758 out:
5759         /*
5760          * Deleting the buffer, clear the corrupt flag since it doesn't matter
5761          * anymore.
5762          */
5763         clear_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags);
5764         btrfs_put_block_group(cache);
5765 }
5766
5767 /* Can return -ENOMEM */
5768 int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root *root,
5769                       u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
5770                       u64 owner, u64 offset, int for_cow)
5771 {
5772         int ret;
5773         struct btrfs_fs_info *fs_info = root->fs_info;
5774
5775         /*
5776          * tree log blocks never actually go into the extent allocation
5777          * tree, just update pinning info and exit early.
5778          */
5779         if (root_objectid == BTRFS_TREE_LOG_OBJECTID) {
5780                 WARN_ON(owner >= BTRFS_FIRST_FREE_OBJECTID);
5781                 /* unlocks the pinned mutex */
5782                 btrfs_pin_extent(root, bytenr, num_bytes, 1);
5783                 ret = 0;
5784         } else if (owner < BTRFS_FIRST_FREE_OBJECTID) {
5785                 ret = btrfs_add_delayed_tree_ref(fs_info, trans, bytenr,
5786                                         num_bytes,
5787                                         parent, root_objectid, (int)owner,
5788                                         BTRFS_DROP_DELAYED_REF, NULL, for_cow);
5789         } else {
5790                 ret = btrfs_add_delayed_data_ref(fs_info, trans, bytenr,
5791                                                 num_bytes,
5792                                                 parent, root_objectid, owner,
5793                                                 offset, BTRFS_DROP_DELAYED_REF,
5794                                                 NULL, for_cow);
5795         }
5796         return ret;
5797 }
5798
5799 static u64 stripe_align(struct btrfs_root *root,
5800                         struct btrfs_block_group_cache *cache,
5801                         u64 val, u64 num_bytes)
5802 {
5803         u64 ret = ALIGN(val, root->stripesize);
5804         return ret;
5805 }
5806
5807 /*
5808  * when we wait for progress in the block group caching, its because
5809  * our allocation attempt failed at least once.  So, we must sleep
5810  * and let some progress happen before we try again.
5811  *
5812  * This function will sleep at least once waiting for new free space to
5813  * show up, and then it will check the block group free space numbers
5814  * for our min num_bytes.  Another option is to have it go ahead
5815  * and look in the rbtree for a free extent of a given size, but this
5816  * is a good start.
5817  */
5818 static noinline int
5819 wait_block_group_cache_progress(struct btrfs_block_group_cache *cache,
5820                                 u64 num_bytes)
5821 {
5822         struct btrfs_caching_control *caching_ctl;
5823
5824         caching_ctl = get_caching_control(cache);
5825         if (!caching_ctl)
5826                 return 0;
5827
5828         wait_event(caching_ctl->wait, block_group_cache_done(cache) ||
5829                    (cache->free_space_ctl->free_space >= num_bytes));
5830
5831         put_caching_control(caching_ctl);
5832         return 0;
5833 }
5834
5835 static noinline int
5836 wait_block_group_cache_done(struct btrfs_block_group_cache *cache)
5837 {
5838         struct btrfs_caching_control *caching_ctl;
5839
5840         caching_ctl = get_caching_control(cache);
5841         if (!caching_ctl)
5842                 return 0;
5843
5844         wait_event(caching_ctl->wait, block_group_cache_done(cache));
5845
5846         put_caching_control(caching_ctl);
5847         return 0;
5848 }
5849
5850 int __get_raid_index(u64 flags)
5851 {
5852         if (flags & BTRFS_BLOCK_GROUP_RAID10)
5853                 return BTRFS_RAID_RAID10;
5854         else if (flags & BTRFS_BLOCK_GROUP_RAID1)
5855                 return BTRFS_RAID_RAID1;
5856         else if (flags & BTRFS_BLOCK_GROUP_DUP)
5857                 return BTRFS_RAID_DUP;
5858         else if (flags & BTRFS_BLOCK_GROUP_RAID0)
5859                 return BTRFS_RAID_RAID0;
5860         else if (flags & BTRFS_BLOCK_GROUP_RAID5)
5861                 return BTRFS_RAID_RAID5;
5862         else if (flags & BTRFS_BLOCK_GROUP_RAID6)
5863                 return BTRFS_RAID_RAID6;
5864
5865         return BTRFS_RAID_SINGLE; /* BTRFS_BLOCK_GROUP_SINGLE */
5866 }
5867
5868 static int get_block_group_index(struct btrfs_block_group_cache *cache)
5869 {
5870         return __get_raid_index(cache->flags);
5871 }
5872
5873 enum btrfs_loop_type {
5874         LOOP_CACHING_NOWAIT = 0,
5875         LOOP_CACHING_WAIT = 1,
5876         LOOP_ALLOC_CHUNK = 2,
5877         LOOP_NO_EMPTY_SIZE = 3,
5878 };
5879
5880 /*
5881  * walks the btree of allocated extents and find a hole of a given size.
5882  * The key ins is changed to record the hole:
5883  * ins->objectid == block start
5884  * ins->flags = BTRFS_EXTENT_ITEM_KEY
5885  * ins->offset == number of blocks
5886  * Any available blocks before search_start are skipped.
5887  */
5888 static noinline int find_free_extent(struct btrfs_trans_handle *trans,
5889                                      struct btrfs_root *orig_root,
5890                                      u64 num_bytes, u64 empty_size,
5891                                      u64 hint_byte, struct btrfs_key *ins,
5892                                      u64 data)
5893 {
5894         int ret = 0;
5895         struct btrfs_root *root = orig_root->fs_info->extent_root;
5896         struct btrfs_free_cluster *last_ptr = NULL;
5897         struct btrfs_block_group_cache *block_group = NULL;
5898         struct btrfs_block_group_cache *used_block_group;
5899         u64 search_start = 0;
5900         int empty_cluster = 2 * 1024 * 1024;
5901         struct btrfs_space_info *space_info;
5902         int loop = 0;
5903         int index = __get_raid_index(data);
5904         int alloc_type = (data & BTRFS_BLOCK_GROUP_DATA) ?
5905                 RESERVE_ALLOC_NO_ACCOUNT : RESERVE_ALLOC;
5906         bool found_uncached_bg = false;
5907         bool failed_cluster_refill = false;
5908         bool failed_alloc = false;
5909         bool use_cluster = true;
5910         bool have_caching_bg = false;
5911
5912         WARN_ON(num_bytes < root->sectorsize);
5913         btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
5914         ins->objectid = 0;
5915         ins->offset = 0;
5916
5917         trace_find_free_extent(orig_root, num_bytes, empty_size, data);
5918
5919         space_info = __find_space_info(root->fs_info, data);
5920         if (!space_info) {
5921                 btrfs_err(root->fs_info, "No space info for %llu", data);
5922                 return -ENOSPC;
5923         }
5924
5925         /*
5926          * If the space info is for both data and metadata it means we have a
5927          * small filesystem and we can't use the clustering stuff.
5928          */
5929         if (btrfs_mixed_space_info(space_info))
5930                 use_cluster = false;
5931
5932         if (data & BTRFS_BLOCK_GROUP_METADATA && use_cluster) {
5933                 last_ptr = &root->fs_info->meta_alloc_cluster;
5934                 if (!btrfs_test_opt(root, SSD))
5935                         empty_cluster = 64 * 1024;
5936         }
5937
5938         if ((data & BTRFS_BLOCK_GROUP_DATA) && use_cluster &&
5939             btrfs_test_opt(root, SSD)) {
5940                 last_ptr = &root->fs_info->data_alloc_cluster;
5941         }
5942
5943         if (last_ptr) {
5944                 spin_lock(&last_ptr->lock);
5945                 if (last_ptr->block_group)
5946                         hint_byte = last_ptr->window_start;
5947                 spin_unlock(&last_ptr->lock);
5948         }
5949
5950         search_start = max(search_start, first_logical_byte(root, 0));
5951         search_start = max(search_start, hint_byte);
5952
5953         if (!last_ptr)
5954                 empty_cluster = 0;
5955
5956         if (search_start == hint_byte) {
5957                 block_group = btrfs_lookup_block_group(root->fs_info,
5958                                                        search_start);
5959                 used_block_group = block_group;
5960                 /*
5961                  * we don't want to use the block group if it doesn't match our
5962                  * allocation bits, or if its not cached.
5963                  *
5964                  * However if we are re-searching with an ideal block group
5965                  * picked out then we don't care that the block group is cached.
5966                  */
5967                 if (block_group && block_group_bits(block_group, data) &&
5968                     block_group->cached != BTRFS_CACHE_NO) {
5969                         down_read(&space_info->groups_sem);
5970                         if (list_empty(&block_group->list) ||
5971                             block_group->ro) {
5972                                 /*
5973                                  * someone is removing this block group,
5974                                  * we can't jump into the have_block_group
5975                                  * target because our list pointers are not
5976                                  * valid
5977                                  */
5978                                 btrfs_put_block_group(block_group);
5979                                 up_read(&space_info->groups_sem);
5980                         } else {
5981                                 index = get_block_group_index(block_group);
5982                                 goto have_block_group;
5983                         }
5984                 } else if (block_group) {
5985                         btrfs_put_block_group(block_group);
5986                 }
5987         }
5988 search:
5989         have_caching_bg = false;
5990         down_read(&space_info->groups_sem);
5991         list_for_each_entry(block_group, &space_info->block_groups[index],
5992                             list) {
5993                 u64 offset;
5994                 int cached;
5995
5996                 used_block_group = block_group;
5997                 btrfs_get_block_group(block_group);
5998                 search_start = block_group->key.objectid;
5999
6000                 /*
6001                  * this can happen if we end up cycling through all the
6002                  * raid types, but we want to make sure we only allocate
6003                  * for the proper type.
6004                  */
6005                 if (!block_group_bits(block_group, data)) {
6006                     u64 extra = BTRFS_BLOCK_GROUP_DUP |
6007                                 BTRFS_BLOCK_GROUP_RAID1 |
6008                                 BTRFS_BLOCK_GROUP_RAID5 |
6009                                 BTRFS_BLOCK_GROUP_RAID6 |
6010                                 BTRFS_BLOCK_GROUP_RAID10;
6011
6012                         /*
6013                          * if they asked for extra copies and this block group
6014                          * doesn't provide them, bail.  This does allow us to
6015                          * fill raid0 from raid1.
6016                          */
6017                         if ((data & extra) && !(block_group->flags & extra))
6018                                 goto loop;
6019                 }
6020
6021 have_block_group:
6022                 cached = block_group_cache_done(block_group);
6023                 if (unlikely(!cached)) {
6024                         found_uncached_bg = true;
6025                         ret = cache_block_group(block_group, 0);
6026                         BUG_ON(ret < 0);
6027                         ret = 0;
6028                 }
6029
6030                 if (unlikely(block_group->ro))
6031                         goto loop;
6032
6033                 /*
6034                  * Ok we want to try and use the cluster allocator, so
6035                  * lets look there
6036                  */
6037                 if (last_ptr) {
6038                         unsigned long aligned_cluster;
6039                         /*
6040                          * the refill lock keeps out other
6041                          * people trying to start a new cluster
6042                          */
6043                         spin_lock(&last_ptr->refill_lock);
6044                         used_block_group = last_ptr->block_group;
6045                         if (used_block_group != block_group &&
6046                             (!used_block_group ||
6047                              used_block_group->ro ||
6048                              !block_group_bits(used_block_group, data))) {
6049                                 used_block_group = block_group;
6050                                 goto refill_cluster;
6051                         }
6052
6053                         if (used_block_group != block_group)
6054                                 btrfs_get_block_group(used_block_group);
6055
6056                         offset = btrfs_alloc_from_cluster(used_block_group,
6057                           last_ptr, num_bytes, used_block_group->key.objectid);
6058                         if (offset) {
6059                                 /* we have a block, we're done */
6060                                 spin_unlock(&last_ptr->refill_lock);
6061                                 trace_btrfs_reserve_extent_cluster(root,
6062                                         block_group, search_start, num_bytes);
6063                                 goto checks;
6064                         }
6065
6066                         WARN_ON(last_ptr->block_group != used_block_group);
6067                         if (used_block_group != block_group) {
6068                                 btrfs_put_block_group(used_block_group);
6069                                 used_block_group = block_group;
6070                         }
6071 refill_cluster:
6072                         BUG_ON(used_block_group != block_group);
6073                         /* If we are on LOOP_NO_EMPTY_SIZE, we can't
6074                          * set up a new clusters, so lets just skip it
6075                          * and let the allocator find whatever block
6076                          * it can find.  If we reach this point, we
6077                          * will have tried the cluster allocator
6078                          * plenty of times and not have found
6079                          * anything, so we are likely way too
6080                          * fragmented for the clustering stuff to find
6081                          * anything.
6082                          *
6083                          * However, if the cluster is taken from the
6084                          * current block group, release the cluster
6085                          * first, so that we stand a better chance of
6086                          * succeeding in the unclustered
6087                          * allocation.  */
6088                         if (loop >= LOOP_NO_EMPTY_SIZE &&
6089                             last_ptr->block_group != block_group) {
6090                                 spin_unlock(&last_ptr->refill_lock);
6091                                 goto unclustered_alloc;
6092                         }
6093
6094                         /*
6095                          * this cluster didn't work out, free it and
6096                          * start over
6097                          */
6098                         btrfs_return_cluster_to_free_space(NULL, last_ptr);
6099
6100                         if (loop >= LOOP_NO_EMPTY_SIZE) {
6101                                 spin_unlock(&last_ptr->refill_lock);
6102                                 goto unclustered_alloc;
6103                         }
6104
6105                         aligned_cluster = max_t(unsigned long,
6106                                                 empty_cluster + empty_size,
6107                                               block_group->full_stripe_len);
6108
6109                         /* allocate a cluster in this block group */
6110                         ret = btrfs_find_space_cluster(trans, root,
6111                                                block_group, last_ptr,
6112                                                search_start, num_bytes,
6113                                                aligned_cluster);
6114                         if (ret == 0) {
6115                                 /*
6116                                  * now pull our allocation out of this
6117                                  * cluster
6118                                  */
6119                                 offset = btrfs_alloc_from_cluster(block_group,
6120                                                   last_ptr, num_bytes,
6121                                                   search_start);
6122                                 if (offset) {
6123                                         /* we found one, proceed */
6124                                         spin_unlock(&last_ptr->refill_lock);
6125                                         trace_btrfs_reserve_extent_cluster(root,
6126                                                 block_group, search_start,
6127                                                 num_bytes);
6128                                         goto checks;
6129                                 }
6130                         } else if (!cached && loop > LOOP_CACHING_NOWAIT
6131                                    && !failed_cluster_refill) {
6132                                 spin_unlock(&last_ptr->refill_lock);
6133
6134                                 failed_cluster_refill = true;
6135                                 wait_block_group_cache_progress(block_group,
6136                                        num_bytes + empty_cluster + empty_size);
6137                                 goto have_block_group;
6138                         }
6139
6140                         /*
6141                          * at this point we either didn't find a cluster
6142                          * or we weren't able to allocate a block from our
6143                          * cluster.  Free the cluster we've been trying
6144                          * to use, and go to the next block group
6145                          */
6146                         btrfs_return_cluster_to_free_space(NULL, last_ptr);
6147                         spin_unlock(&last_ptr->refill_lock);
6148                         goto loop;
6149                 }
6150
6151 unclustered_alloc:
6152                 spin_lock(&block_group->free_space_ctl->tree_lock);
6153                 if (cached &&
6154                     block_group->free_space_ctl->free_space <
6155                     num_bytes + empty_cluster + empty_size) {
6156                         spin_unlock(&block_group->free_space_ctl->tree_lock);
6157                         goto loop;
6158                 }
6159                 spin_unlock(&block_group->free_space_ctl->tree_lock);
6160
6161                 offset = btrfs_find_space_for_alloc(block_group, search_start,
6162                                                     num_bytes, empty_size);
6163                 /*
6164                  * If we didn't find a chunk, and we haven't failed on this
6165                  * block group before, and this block group is in the middle of
6166                  * caching and we are ok with waiting, then go ahead and wait
6167                  * for progress to be made, and set failed_alloc to true.
6168                  *
6169                  * If failed_alloc is true then we've already waited on this
6170                  * block group once and should move on to the next block group.
6171                  */
6172                 if (!offset && !failed_alloc && !cached &&
6173                     loop > LOOP_CACHING_NOWAIT) {
6174                         wait_block_group_cache_progress(block_group,
6175                                                 num_bytes + empty_size);
6176                         failed_alloc = true;
6177                         goto have_block_group;
6178                 } else if (!offset) {
6179                         if (!cached)
6180                                 have_caching_bg = true;
6181                         goto loop;
6182                 }
6183 checks:
6184                 search_start = stripe_align(root, used_block_group,
6185                                             offset, num_bytes);
6186
6187                 /* move on to the next group */
6188                 if (search_start + num_bytes >
6189                     used_block_group->key.objectid + used_block_group->key.offset) {
6190                         btrfs_add_free_space(used_block_group, offset, num_bytes);
6191                         goto loop;
6192                 }
6193
6194                 if (offset < search_start)
6195                         btrfs_add_free_space(used_block_group, offset,
6196                                              search_start - offset);
6197                 BUG_ON(offset > search_start);
6198
6199                 ret = btrfs_update_reserved_bytes(used_block_group, num_bytes,
6200                                                   alloc_type);
6201                 if (ret == -EAGAIN) {
6202                         btrfs_add_free_space(used_block_group, offset, num_bytes);
6203                         goto loop;
6204                 }
6205
6206                 /* we are all good, lets return */
6207                 ins->objectid = search_start;
6208                 ins->offset = num_bytes;
6209
6210                 trace_btrfs_reserve_extent(orig_root, block_group,
6211                                            search_start, num_bytes);
6212                 if (used_block_group != block_group)
6213                         btrfs_put_block_group(used_block_group);
6214                 btrfs_put_block_group(block_group);
6215                 break;
6216 loop:
6217                 failed_cluster_refill = false;
6218                 failed_alloc = false;
6219                 BUG_ON(index != get_block_group_index(block_group));
6220                 if (used_block_group != block_group)
6221                         btrfs_put_block_group(used_block_group);
6222                 btrfs_put_block_group(block_group);
6223         }
6224         up_read(&space_info->groups_sem);
6225
6226         if (!ins->objectid && loop >= LOOP_CACHING_WAIT && have_caching_bg)
6227                 goto search;
6228
6229         if (!ins->objectid && ++index < BTRFS_NR_RAID_TYPES)
6230                 goto search;
6231
6232         /*
6233          * LOOP_CACHING_NOWAIT, search partially cached block groups, kicking
6234          *                      caching kthreads as we move along
6235          * LOOP_CACHING_WAIT, search everything, and wait if our bg is caching
6236          * LOOP_ALLOC_CHUNK, force a chunk allocation and try again
6237          * LOOP_NO_EMPTY_SIZE, set empty_size and empty_cluster to 0 and try
6238          *                      again
6239          */
6240         if (!ins->objectid && loop < LOOP_NO_EMPTY_SIZE) {
6241                 index = 0;
6242                 loop++;
6243                 if (loop == LOOP_ALLOC_CHUNK) {
6244                         ret = do_chunk_alloc(trans, root, data,
6245                                              CHUNK_ALLOC_FORCE);
6246                         /*
6247                          * Do not bail out on ENOSPC since we
6248                          * can do more things.
6249                          */
6250                         if (ret < 0 && ret != -ENOSPC) {
6251                                 btrfs_abort_transaction(trans,
6252                                                         root, ret);
6253                                 goto out;
6254                         }
6255                 }
6256
6257                 if (loop == LOOP_NO_EMPTY_SIZE) {
6258                         empty_size = 0;
6259                         empty_cluster = 0;
6260                 }
6261
6262                 goto search;
6263         } else if (!ins->objectid) {
6264                 ret = -ENOSPC;
6265         } else if (ins->objectid) {
6266                 ret = 0;
6267         }
6268 out:
6269
6270         return ret;
6271 }
6272
6273 static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
6274                             int dump_block_groups)
6275 {
6276         struct btrfs_block_group_cache *cache;
6277         int index = 0;
6278
6279         spin_lock(&info->lock);
6280         printk(KERN_INFO "space_info %llu has %llu free, is %sfull\n",
6281                (unsigned long long)info->flags,
6282                (unsigned long long)(info->total_bytes - info->bytes_used -
6283                                     info->bytes_pinned - info->bytes_reserved -
6284                                     info->bytes_readonly),
6285                (info->full) ? "" : "not ");
6286         printk(KERN_INFO "space_info total=%llu, used=%llu, pinned=%llu, "
6287                "reserved=%llu, may_use=%llu, readonly=%llu\n",
6288                (unsigned long long)info->total_bytes,
6289                (unsigned long long)info->bytes_used,
6290                (unsigned long long)info->bytes_pinned,
6291                (unsigned long long)info->bytes_reserved,
6292                (unsigned long long)info->bytes_may_use,
6293                (unsigned long long)info->bytes_readonly);
6294         spin_unlock(&info->lock);
6295
6296         if (!dump_block_groups)
6297                 return;
6298
6299         down_read(&info->groups_sem);
6300 again:
6301         list_for_each_entry(cache, &info->block_groups[index], list) {
6302                 spin_lock(&cache->lock);
6303                 printk(KERN_INFO "block group %llu has %llu bytes, %llu used %llu pinned %llu reserved %s\n",
6304                        (unsigned long long)cache->key.objectid,
6305                        (unsigned long long)cache->key.offset,
6306                        (unsigned long long)btrfs_block_group_used(&cache->item),
6307                        (unsigned long long)cache->pinned,
6308                        (unsigned long long)cache->reserved,
6309                        cache->ro ? "[readonly]" : "");
6310                 btrfs_dump_free_space(cache, bytes);
6311                 spin_unlock(&cache->lock);
6312         }
6313         if (++index < BTRFS_NR_RAID_TYPES)
6314                 goto again;
6315         up_read(&info->groups_sem);
6316 }
6317
6318 int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
6319                          struct btrfs_root *root,
6320                          u64 num_bytes, u64 min_alloc_size,
6321                          u64 empty_size, u64 hint_byte,
6322                          struct btrfs_key *ins, u64 data)
6323 {
6324         bool final_tried = false;
6325         int ret;
6326
6327         data = btrfs_get_alloc_profile(root, data);
6328 again:
6329         WARN_ON(num_bytes < root->sectorsize);
6330         ret = find_free_extent(trans, root, num_bytes, empty_size,
6331                                hint_byte, ins, data);
6332
6333         if (ret == -ENOSPC) {
6334                 if (!final_tried) {
6335                         num_bytes = num_bytes >> 1;
6336                         num_bytes = round_down(num_bytes, root->sectorsize);
6337                         num_bytes = max(num_bytes, min_alloc_size);
6338                         if (num_bytes == min_alloc_size)
6339                                 final_tried = true;
6340                         goto again;
6341                 } else if (btrfs_test_opt(root, ENOSPC_DEBUG)) {
6342                         struct btrfs_space_info *sinfo;
6343
6344                         sinfo = __find_space_info(root->fs_info, data);
6345                         btrfs_err(root->fs_info, "allocation failed flags %llu, wanted %llu",
6346                                 (unsigned long long)data,
6347                                 (unsigned long long)num_bytes);
6348                         if (sinfo)
6349                                 dump_space_info(sinfo, num_bytes, 1);
6350                 }
6351         }
6352
6353         trace_btrfs_reserved_extent_alloc(root, ins->objectid, ins->offset);
6354
6355         return ret;
6356 }
6357
6358 static int __btrfs_free_reserved_extent(struct btrfs_root *root,
6359                                         u64 start, u64 len, int pin)
6360 {
6361         struct btrfs_block_group_cache *cache;
6362         int ret = 0;
6363
6364         cache = btrfs_lookup_block_group(root->fs_info, start);
6365         if (!cache) {
6366                 btrfs_err(root->fs_info, "Unable to find block group for %llu",
6367                         (unsigned long long)start);
6368                 return -ENOSPC;
6369         }
6370
6371         if (btrfs_test_opt(root, DISCARD))
6372                 ret = btrfs_discard_extent(root, start, len, NULL);
6373
6374         if (pin)
6375                 pin_down_extent(root, cache, start, len, 1);
6376         else {
6377                 btrfs_add_free_space(cache, start, len);
6378                 btrfs_update_reserved_bytes(cache, len, RESERVE_FREE);
6379         }
6380         btrfs_put_block_group(cache);
6381
6382         trace_btrfs_reserved_extent_free(root, start, len);
6383
6384         return ret;
6385 }
6386
6387 int btrfs_free_reserved_extent(struct btrfs_root *root,
6388                                         u64 start, u64 len)
6389 {
6390         return __btrfs_free_reserved_extent(root, start, len, 0);
6391 }
6392
6393 int btrfs_free_and_pin_reserved_extent(struct btrfs_root *root,
6394                                        u64 start, u64 len)
6395 {
6396         return __btrfs_free_reserved_extent(root, start, len, 1);
6397 }
6398
6399 static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
6400                                       struct btrfs_root *root,
6401                                       u64 parent, u64 root_objectid,
6402                                       u64 flags, u64 owner, u64 offset,
6403                                       struct btrfs_key *ins, int ref_mod)
6404 {
6405         int ret;
6406         struct btrfs_fs_info *fs_info = root->fs_info;
6407         struct btrfs_extent_item *extent_item;
6408         struct btrfs_extent_inline_ref *iref;
6409         struct btrfs_path *path;
6410         struct extent_buffer *leaf;
6411         int type;
6412         u32 size;
6413
6414         if (parent > 0)
6415                 type = BTRFS_SHARED_DATA_REF_KEY;
6416         else
6417                 type = BTRFS_EXTENT_DATA_REF_KEY;
6418
6419         size = sizeof(*extent_item) + btrfs_extent_inline_ref_size(type);
6420
6421         path = btrfs_alloc_path();
6422         if (!path)
6423                 return -ENOMEM;
6424
6425         path->leave_spinning = 1;
6426         ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
6427                                       ins, size);
6428         if (ret) {
6429                 btrfs_free_path(path);
6430                 return ret;
6431         }
6432
6433         leaf = path->nodes[0];
6434         extent_item = btrfs_item_ptr(leaf, path->slots[0],
6435                                      struct btrfs_extent_item);
6436         btrfs_set_extent_refs(leaf, extent_item, ref_mod);
6437         btrfs_set_extent_generation(leaf, extent_item, trans->transid);
6438         btrfs_set_extent_flags(leaf, extent_item,
6439                                flags | BTRFS_EXTENT_FLAG_DATA);
6440
6441         iref = (struct btrfs_extent_inline_ref *)(extent_item + 1);
6442         btrfs_set_extent_inline_ref_type(leaf, iref, type);
6443         if (parent > 0) {
6444                 struct btrfs_shared_data_ref *ref;
6445                 ref = (struct btrfs_shared_data_ref *)(iref + 1);
6446                 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
6447                 btrfs_set_shared_data_ref_count(leaf, ref, ref_mod);
6448         } else {
6449                 struct btrfs_extent_data_ref *ref;
6450                 ref = (struct btrfs_extent_data_ref *)(&iref->offset);
6451                 btrfs_set_extent_data_ref_root(leaf, ref, root_objectid);
6452                 btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
6453                 btrfs_set_extent_data_ref_offset(leaf, ref, offset);
6454                 btrfs_set_extent_data_ref_count(leaf, ref, ref_mod);
6455         }
6456
6457         btrfs_mark_buffer_dirty(path->nodes[0]);
6458         btrfs_free_path(path);
6459
6460         ret = update_block_group(root, ins->objectid, ins->offset, 1);
6461         if (ret) { /* -ENOENT, logic error */
6462                 btrfs_err(fs_info, "update block group failed for %llu %llu",
6463                         (unsigned long long)ins->objectid,
6464                         (unsigned long long)ins->offset);
6465                 BUG();
6466         }
6467         return ret;
6468 }
6469
6470 static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
6471                                      struct btrfs_root *root,
6472                                      u64 parent, u64 root_objectid,
6473                                      u64 flags, struct btrfs_disk_key *key,
6474                                      int level, struct btrfs_key *ins)
6475 {
6476         int ret;
6477         struct btrfs_fs_info *fs_info = root->fs_info;
6478         struct btrfs_extent_item *extent_item;
6479         struct btrfs_tree_block_info *block_info;
6480         struct btrfs_extent_inline_ref *iref;
6481         struct btrfs_path *path;
6482         struct extent_buffer *leaf;
6483         u32 size = sizeof(*extent_item) + sizeof(*iref);
6484         bool skinny_metadata = btrfs_fs_incompat(root->fs_info,
6485                                                  SKINNY_METADATA);
6486
6487         if (!skinny_metadata)
6488                 size += sizeof(*block_info);
6489
6490         path = btrfs_alloc_path();
6491         if (!path)
6492                 return -ENOMEM;
6493
6494         path->leave_spinning = 1;
6495         ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
6496                                       ins, size);
6497         if (ret) {
6498                 btrfs_free_path(path);
6499                 return ret;
6500         }
6501
6502         leaf = path->nodes[0];
6503         extent_item = btrfs_item_ptr(leaf, path->slots[0],
6504                                      struct btrfs_extent_item);
6505         btrfs_set_extent_refs(leaf, extent_item, 1);
6506         btrfs_set_extent_generation(leaf, extent_item, trans->transid);
6507         btrfs_set_extent_flags(leaf, extent_item,
6508                                flags | BTRFS_EXTENT_FLAG_TREE_BLOCK);
6509
6510         if (skinny_metadata) {
6511                 iref = (struct btrfs_extent_inline_ref *)(extent_item + 1);
6512         } else {
6513                 block_info = (struct btrfs_tree_block_info *)(extent_item + 1);
6514                 btrfs_set_tree_block_key(leaf, block_info, key);
6515                 btrfs_set_tree_block_level(leaf, block_info, level);
6516                 iref = (struct btrfs_extent_inline_ref *)(block_info + 1);
6517         }
6518
6519         if (parent > 0) {
6520                 BUG_ON(!(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF));
6521                 btrfs_set_extent_inline_ref_type(leaf, iref,
6522                                                  BTRFS_SHARED_BLOCK_REF_KEY);
6523                 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
6524         } else {
6525                 btrfs_set_extent_inline_ref_type(leaf, iref,
6526                                                  BTRFS_TREE_BLOCK_REF_KEY);
6527                 btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
6528         }
6529
6530         btrfs_mark_buffer_dirty(leaf);
6531         btrfs_free_path(path);
6532
6533         ret = update_block_group(root, ins->objectid, root->leafsize, 1);
6534         if (ret) { /* -ENOENT, logic error */
6535                 btrfs_err(fs_info, "update block group failed for %llu %llu",
6536                         (unsigned long long)ins->objectid,
6537                         (unsigned long long)ins->offset);
6538                 BUG();
6539         }
6540         return ret;
6541 }
6542
6543 int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
6544                                      struct btrfs_root *root,
6545                                      u64 root_objectid, u64 owner,
6546                                      u64 offset, struct btrfs_key *ins)
6547 {
6548         int ret;
6549
6550         BUG_ON(root_objectid == BTRFS_TREE_LOG_OBJECTID);
6551
6552         ret = btrfs_add_delayed_data_ref(root->fs_info, trans, ins->objectid,
6553                                          ins->offset, 0,
6554                                          root_objectid, owner, offset,
6555                                          BTRFS_ADD_DELAYED_EXTENT, NULL, 0);
6556         return ret;
6557 }
6558
6559 /*
6560  * this is used by the tree logging recovery code.  It records that
6561  * an extent has been allocated and makes sure to clear the free
6562  * space cache bits as well
6563  */
6564 int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
6565                                    struct btrfs_root *root,
6566                                    u64 root_objectid, u64 owner, u64 offset,
6567                                    struct btrfs_key *ins)
6568 {
6569         int ret;
6570         struct btrfs_block_group_cache *block_group;
6571         struct btrfs_caching_control *caching_ctl;
6572         u64 start = ins->objectid;
6573         u64 num_bytes = ins->offset;
6574
6575         block_group = btrfs_lookup_block_group(root->fs_info, ins->objectid);
6576         cache_block_group(block_group, 0);
6577         caching_ctl = get_caching_control(block_group);
6578
6579         if (!caching_ctl) {
6580                 BUG_ON(!block_group_cache_done(block_group));
6581                 ret = btrfs_remove_free_space(block_group, start, num_bytes);
6582                 BUG_ON(ret); /* -ENOMEM */
6583         } else {
6584                 mutex_lock(&caching_ctl->mutex);
6585
6586                 if (start >= caching_ctl->progress) {
6587                         ret = add_excluded_extent(root, start, num_bytes);
6588                         BUG_ON(ret); /* -ENOMEM */
6589                 } else if (start + num_bytes <= caching_ctl->progress) {
6590                         ret = btrfs_remove_free_space(block_group,
6591                                                       start, num_bytes);
6592                         BUG_ON(ret); /* -ENOMEM */
6593                 } else {
6594                         num_bytes = caching_ctl->progress - start;
6595                         ret = btrfs_remove_free_space(block_group,
6596                                                       start, num_bytes);
6597                         BUG_ON(ret); /* -ENOMEM */
6598
6599                         start = caching_ctl->progress;
6600                         num_bytes = ins->objectid + ins->offset -
6601                                     caching_ctl->progress;
6602                         ret = add_excluded_extent(root, start, num_bytes);
6603                         BUG_ON(ret); /* -ENOMEM */
6604                 }
6605
6606                 mutex_unlock(&caching_ctl->mutex);
6607                 put_caching_control(caching_ctl);
6608         }
6609
6610         ret = btrfs_update_reserved_bytes(block_group, ins->offset,
6611                                           RESERVE_ALLOC_NO_ACCOUNT);
6612         BUG_ON(ret); /* logic error */
6613         btrfs_put_block_group(block_group);
6614         ret = alloc_reserved_file_extent(trans, root, 0, root_objectid,
6615                                          0, owner, offset, ins, 1);
6616         return ret;
6617 }
6618
6619 struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans,
6620                                             struct btrfs_root *root,
6621                                             u64 bytenr, u32 blocksize,
6622                                             int level)
6623 {
6624         struct extent_buffer *buf;
6625
6626         buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
6627         if (!buf)
6628                 return ERR_PTR(-ENOMEM);
6629         btrfs_set_header_generation(buf, trans->transid);
6630         btrfs_set_buffer_lockdep_class(root->root_key.objectid, buf, level);
6631         btrfs_tree_lock(buf);
6632         clean_tree_block(trans, root, buf);
6633         clear_bit(EXTENT_BUFFER_STALE, &buf->bflags);
6634
6635         btrfs_set_lock_blocking(buf);
6636         btrfs_set_buffer_uptodate(buf);
6637
6638         if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
6639                 /*
6640                  * we allow two log transactions at a time, use different
6641                  * EXENT bit to differentiate dirty pages.
6642                  */
6643                 if (root->log_transid % 2 == 0)
6644                         set_extent_dirty(&root->dirty_log_pages, buf->start,
6645                                         buf->start + buf->len - 1, GFP_NOFS);
6646                 else
6647                         set_extent_new(&root->dirty_log_pages, buf->start,
6648                                         buf->start + buf->len - 1, GFP_NOFS);
6649         } else {
6650                 set_extent_dirty(&trans->transaction->dirty_pages, buf->start,
6651                          buf->start + buf->len - 1, GFP_NOFS);
6652         }
6653         trans->blocks_used++;
6654         /* this returns a buffer locked for blocking */
6655         return buf;
6656 }
6657
6658 static struct btrfs_block_rsv *
6659 use_block_rsv(struct btrfs_trans_handle *trans,
6660               struct btrfs_root *root, u32 blocksize)
6661 {
6662         struct btrfs_block_rsv *block_rsv;
6663         struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
6664         int ret;
6665
6666         block_rsv = get_block_rsv(trans, root);
6667
6668         if (block_rsv->size == 0) {
6669                 ret = reserve_metadata_bytes(root, block_rsv, blocksize,
6670                                              BTRFS_RESERVE_NO_FLUSH);
6671                 /*
6672                  * If we couldn't reserve metadata bytes try and use some from
6673                  * the global reserve.
6674                  */
6675                 if (ret && block_rsv != global_rsv) {
6676                         ret = block_rsv_use_bytes(global_rsv, blocksize);
6677                         if (!ret)
6678                                 return global_rsv;
6679                         return ERR_PTR(ret);
6680                 } else if (ret) {
6681                         return ERR_PTR(ret);
6682                 }
6683                 return block_rsv;
6684         }
6685
6686         ret = block_rsv_use_bytes(block_rsv, blocksize);
6687         if (!ret)
6688                 return block_rsv;
6689         if (ret && !block_rsv->failfast) {
6690                 if (btrfs_test_opt(root, ENOSPC_DEBUG)) {
6691                         static DEFINE_RATELIMIT_STATE(_rs,
6692                                         DEFAULT_RATELIMIT_INTERVAL * 10,
6693                                         /*DEFAULT_RATELIMIT_BURST*/ 1);
6694                         if (__ratelimit(&_rs))
6695                                 WARN(1, KERN_DEBUG
6696                                         "btrfs: block rsv returned %d\n", ret);
6697                 }
6698                 ret = reserve_metadata_bytes(root, block_rsv, blocksize,
6699                                              BTRFS_RESERVE_NO_FLUSH);
6700                 if (!ret) {
6701                         return block_rsv;
6702                 } else if (ret && block_rsv != global_rsv) {
6703                         ret = block_rsv_use_bytes(global_rsv, blocksize);
6704                         if (!ret)
6705                                 return global_rsv;
6706                 }
6707         }
6708
6709         return ERR_PTR(-ENOSPC);
6710 }
6711
6712 static void unuse_block_rsv(struct btrfs_fs_info *fs_info,
6713                             struct btrfs_block_rsv *block_rsv, u32 blocksize)
6714 {
6715         block_rsv_add_bytes(block_rsv, blocksize, 0);
6716         block_rsv_release_bytes(fs_info, block_rsv, NULL, 0);
6717 }
6718
6719 /*
6720  * finds a free extent and does all the dirty work required for allocation
6721  * returns the key for the extent through ins, and a tree buffer for
6722  * the first block of the extent through buf.
6723  *
6724  * returns the tree buffer or NULL.
6725  */
6726 struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
6727                                         struct btrfs_root *root, u32 blocksize,
6728                                         u64 parent, u64 root_objectid,
6729                                         struct btrfs_disk_key *key, int level,
6730                                         u64 hint, u64 empty_size)
6731 {
6732         struct btrfs_key ins;
6733         struct btrfs_block_rsv *block_rsv;
6734         struct extent_buffer *buf;
6735         u64 flags = 0;
6736         int ret;
6737         bool skinny_metadata = btrfs_fs_incompat(root->fs_info,
6738                                                  SKINNY_METADATA);
6739
6740         block_rsv = use_block_rsv(trans, root, blocksize);
6741         if (IS_ERR(block_rsv))
6742                 return ERR_CAST(block_rsv);
6743
6744         ret = btrfs_reserve_extent(trans, root, blocksize, blocksize,
6745                                    empty_size, hint, &ins, 0);
6746         if (ret) {
6747                 unuse_block_rsv(root->fs_info, block_rsv, blocksize);
6748                 return ERR_PTR(ret);
6749         }
6750
6751         buf = btrfs_init_new_buffer(trans, root, ins.objectid,
6752                                     blocksize, level);
6753         BUG_ON(IS_ERR(buf)); /* -ENOMEM */
6754
6755         if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
6756                 if (parent == 0)
6757                         parent = ins.objectid;
6758                 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
6759         } else
6760                 BUG_ON(parent > 0);
6761
6762         if (root_objectid != BTRFS_TREE_LOG_OBJECTID) {
6763                 struct btrfs_delayed_extent_op *extent_op;
6764                 extent_op = btrfs_alloc_delayed_extent_op();
6765                 BUG_ON(!extent_op); /* -ENOMEM */
6766                 if (key)
6767                         memcpy(&extent_op->key, key, sizeof(extent_op->key));
6768                 else
6769                         memset(&extent_op->key, 0, sizeof(extent_op->key));
6770                 extent_op->flags_to_set = flags;
6771                 if (skinny_metadata)
6772                         extent_op->update_key = 0;
6773                 else
6774                         extent_op->update_key = 1;
6775                 extent_op->update_flags = 1;
6776                 extent_op->is_data = 0;
6777
6778                 ret = btrfs_add_delayed_tree_ref(root->fs_info, trans,
6779                                         ins.objectid,
6780                                         ins.offset, parent, root_objectid,
6781                                         level, BTRFS_ADD_DELAYED_EXTENT,
6782                                         extent_op, 0);
6783                 BUG_ON(ret); /* -ENOMEM */
6784         }
6785         return buf;
6786 }
6787
6788 struct walk_control {
6789         u64 refs[BTRFS_MAX_LEVEL];
6790         u64 flags[BTRFS_MAX_LEVEL];
6791         struct btrfs_key update_progress;
6792         int stage;
6793         int level;
6794         int shared_level;
6795         int update_ref;
6796         int keep_locks;
6797         int reada_slot;
6798         int reada_count;
6799         int for_reloc;
6800 };
6801
6802 #define DROP_REFERENCE  1
6803 #define UPDATE_BACKREF  2
6804
6805 static noinline void reada_walk_down(struct btrfs_trans_handle *trans,
6806                                      struct btrfs_root *root,
6807                                      struct walk_control *wc,
6808                                      struct btrfs_path *path)
6809 {
6810         u64 bytenr;
6811         u64 generation;
6812         u64 refs;
6813         u64 flags;
6814         u32 nritems;
6815         u32 blocksize;
6816         struct btrfs_key key;
6817         struct extent_buffer *eb;
6818         int ret;
6819         int slot;
6820         int nread = 0;
6821
6822         if (path->slots[wc->level] < wc->reada_slot) {
6823                 wc->reada_count = wc->reada_count * 2 / 3;
6824                 wc->reada_count = max(wc->reada_count, 2);
6825         } else {
6826                 wc->reada_count = wc->reada_count * 3 / 2;
6827                 wc->reada_count = min_t(int, wc->reada_count,
6828                                         BTRFS_NODEPTRS_PER_BLOCK(root));
6829         }
6830
6831         eb = path->nodes[wc->level];
6832         nritems = btrfs_header_nritems(eb);
6833         blocksize = btrfs_level_size(root, wc->level - 1);
6834
6835         for (slot = path->slots[wc->level]; slot < nritems; slot++) {
6836                 if (nread >= wc->reada_count)
6837                         break;
6838
6839                 cond_resched();
6840                 bytenr = btrfs_node_blockptr(eb, slot);
6841                 generation = btrfs_node_ptr_generation(eb, slot);
6842
6843                 if (slot == path->slots[wc->level])
6844                         goto reada;
6845
6846                 if (wc->stage == UPDATE_BACKREF &&
6847                     generation <= root->root_key.offset)
6848                         continue;
6849
6850                 /* We don't lock the tree block, it's OK to be racy here */
6851                 ret = btrfs_lookup_extent_info(trans, root, bytenr,
6852                                                wc->level - 1, 1, &refs,
6853                                                &flags);
6854                 /* We don't care about errors in readahead. */
6855                 if (ret < 0)
6856                         continue;
6857                 BUG_ON(refs == 0);
6858
6859                 if (wc->stage == DROP_REFERENCE) {
6860                         if (refs == 1)
6861                                 goto reada;
6862
6863                         if (wc->level == 1 &&
6864                             (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
6865                                 continue;
6866                         if (!wc->update_ref ||
6867                             generation <= root->root_key.offset)
6868                                 continue;
6869                         btrfs_node_key_to_cpu(eb, &key, slot);
6870                         ret = btrfs_comp_cpu_keys(&key,
6871                                                   &wc->update_progress);
6872                         if (ret < 0)
6873                                 continue;
6874                 } else {
6875                         if (wc->level == 1 &&
6876                             (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
6877                                 continue;
6878                 }
6879 reada:
6880                 ret = readahead_tree_block(root, bytenr, blocksize,
6881                                            generation);
6882                 if (ret)
6883                         break;
6884                 nread++;
6885         }
6886         wc->reada_slot = slot;
6887 }
6888
6889 /*
6890  * helper to process tree block while walking down the tree.
6891  *
6892  * when wc->stage == UPDATE_BACKREF, this function updates
6893  * back refs for pointers in the block.
6894  *
6895  * NOTE: return value 1 means we should stop walking down.
6896  */
6897 static noinline int walk_down_proc(struct btrfs_trans_handle *trans,
6898                                    struct btrfs_root *root,
6899                                    struct btrfs_path *path,
6900                                    struct walk_control *wc, int lookup_info)
6901 {
6902         int level = wc->level;
6903         struct extent_buffer *eb = path->nodes[level];
6904         u64 flag = BTRFS_BLOCK_FLAG_FULL_BACKREF;
6905         int ret;
6906
6907         if (wc->stage == UPDATE_BACKREF &&
6908             btrfs_header_owner(eb) != root->root_key.objectid)
6909                 return 1;
6910
6911         /*
6912          * when reference count of tree block is 1, it won't increase
6913          * again. once full backref flag is set, we never clear it.
6914          */
6915         if (lookup_info &&
6916             ((wc->stage == DROP_REFERENCE && wc->refs[level] != 1) ||
6917              (wc->stage == UPDATE_BACKREF && !(wc->flags[level] & flag)))) {
6918                 BUG_ON(!path->locks[level]);
6919                 ret = btrfs_lookup_extent_info(trans, root,
6920                                                eb->start, level, 1,
6921                                                &wc->refs[level],
6922                                                &wc->flags[level]);
6923                 BUG_ON(ret == -ENOMEM);
6924                 if (ret)
6925                         return ret;
6926                 BUG_ON(wc->refs[level] == 0);
6927         }
6928
6929         if (wc->stage == DROP_REFERENCE) {
6930                 if (wc->refs[level] > 1)
6931                         return 1;
6932
6933                 if (path->locks[level] && !wc->keep_locks) {
6934                         btrfs_tree_unlock_rw(eb, path->locks[level]);
6935                         path->locks[level] = 0;
6936                 }
6937                 return 0;
6938         }
6939
6940         /* wc->stage == UPDATE_BACKREF */
6941         if (!(wc->flags[level] & flag)) {
6942                 BUG_ON(!path->locks[level]);
6943                 ret = btrfs_inc_ref(trans, root, eb, 1, wc->for_reloc);
6944                 BUG_ON(ret); /* -ENOMEM */
6945                 ret = btrfs_dec_ref(trans, root, eb, 0, wc->for_reloc);
6946                 BUG_ON(ret); /* -ENOMEM */
6947                 ret = btrfs_set_disk_extent_flags(trans, root, eb->start,
6948                                                   eb->len, flag, 0);
6949                 BUG_ON(ret); /* -ENOMEM */
6950                 wc->flags[level] |= flag;
6951         }
6952
6953         /*
6954          * the block is shared by multiple trees, so it's not good to
6955          * keep the tree lock
6956          */
6957         if (path->locks[level] && level > 0) {
6958                 btrfs_tree_unlock_rw(eb, path->locks[level]);
6959                 path->locks[level] = 0;
6960         }
6961         return 0;
6962 }
6963
6964 /*
6965  * helper to process tree block pointer.
6966  *
6967  * when wc->stage == DROP_REFERENCE, this function checks
6968  * reference count of the block pointed to. if the block
6969  * is shared and we need update back refs for the subtree
6970  * rooted at the block, this function changes wc->stage to
6971  * UPDATE_BACKREF. if the block is shared and there is no
6972  * need to update back, this function drops the reference
6973  * to the block.
6974  *
6975  * NOTE: return value 1 means we should stop walking down.
6976  */
6977 static noinline int do_walk_down(struct btrfs_trans_handle *trans,
6978                                  struct btrfs_root *root,
6979                                  struct btrfs_path *path,
6980                                  struct walk_control *wc, int *lookup_info)
6981 {
6982         u64 bytenr;
6983         u64 generation;
6984         u64 parent;
6985         u32 blocksize;
6986         struct btrfs_key key;
6987         struct extent_buffer *next;
6988         int level = wc->level;
6989         int reada = 0;
6990         int ret = 0;
6991
6992         generation = btrfs_node_ptr_generation(path->nodes[level],
6993                                                path->slots[level]);
6994         /*
6995          * if the lower level block was created before the snapshot
6996          * was created, we know there is no need to update back refs
6997          * for the subtree
6998          */
6999         if (wc->stage == UPDATE_BACKREF &&
7000             generation <= root->root_key.offset) {
7001                 *lookup_info = 1;
7002                 return 1;
7003         }
7004
7005         bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);
7006         blocksize = btrfs_level_size(root, level - 1);
7007
7008         next = btrfs_find_tree_block(root, bytenr, blocksize);
7009         if (!next) {
7010                 next = btrfs_find_create_tree_block(root, bytenr, blocksize);
7011                 if (!next)
7012                         return -ENOMEM;
7013                 reada = 1;
7014         }
7015         btrfs_tree_lock(next);
7016         btrfs_set_lock_blocking(next);
7017
7018         ret = btrfs_lookup_extent_info(trans, root, bytenr, level - 1, 1,
7019                                        &wc->refs[level - 1],
7020                                        &wc->flags[level - 1]);
7021         if (ret < 0) {
7022                 btrfs_tree_unlock(next);
7023                 return ret;
7024         }
7025
7026         if (unlikely(wc->refs[level - 1] == 0)) {
7027                 btrfs_err(root->fs_info, "Missing references.");
7028                 BUG();
7029         }
7030         *lookup_info = 0;
7031
7032         if (wc->stage == DROP_REFERENCE) {
7033                 if (wc->refs[level - 1] > 1) {
7034                         if (level == 1 &&
7035                             (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
7036                                 goto skip;
7037
7038                         if (!wc->update_ref ||
7039                             generation <= root->root_key.offset)
7040                                 goto skip;
7041
7042                         btrfs_node_key_to_cpu(path->nodes[level], &key,
7043                                               path->slots[level]);
7044                         ret = btrfs_comp_cpu_keys(&key, &wc->update_progress);
7045                         if (ret < 0)
7046                                 goto skip;
7047
7048                         wc->stage = UPDATE_BACKREF;
7049                         wc->shared_level = level - 1;
7050                 }
7051         } else {
7052                 if (level == 1 &&
7053                     (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
7054                         goto skip;
7055         }
7056
7057         if (!btrfs_buffer_uptodate(next, generation, 0)) {
7058                 btrfs_tree_unlock(next);
7059                 free_extent_buffer(next);
7060                 next = NULL;
7061                 *lookup_info = 1;
7062         }
7063
7064         if (!next) {
7065                 if (reada && level == 1)
7066                         reada_walk_down(trans, root, wc, path);
7067                 next = read_tree_block(root, bytenr, blocksize, generation);
7068                 if (!next)
7069                         return -EIO;
7070                 btrfs_tree_lock(next);
7071                 btrfs_set_lock_blocking(next);
7072         }
7073
7074         level--;
7075         BUG_ON(level != btrfs_header_level(next));
7076         path->nodes[level] = next;
7077         path->slots[level] = 0;
7078         path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
7079         wc->level = level;
7080         if (wc->level == 1)
7081                 wc->reada_slot = 0;
7082         return 0;
7083 skip:
7084         wc->refs[level - 1] = 0;
7085         wc->flags[level - 1] = 0;
7086         if (wc->stage == DROP_REFERENCE) {
7087                 if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7088                         parent = path->nodes[level]->start;
7089                 } else {
7090                         BUG_ON(root->root_key.objectid !=
7091                                btrfs_header_owner(path->nodes[level]));
7092                         parent = 0;
7093                 }
7094
7095                 ret = btrfs_free_extent(trans, root, bytenr, blocksize, parent,
7096                                 root->root_key.objectid, level - 1, 0, 0);
7097                 BUG_ON(ret); /* -ENOMEM */
7098         }
7099         btrfs_tree_unlock(next);
7100         free_extent_buffer(next);
7101         *lookup_info = 1;
7102         return 1;
7103 }
7104
7105 /*
7106  * helper to process tree block while walking up the tree.
7107  *
7108  * when wc->stage == DROP_REFERENCE, this function drops
7109  * reference count on the block.
7110  *
7111  * when wc->stage == UPDATE_BACKREF, this function changes
7112  * wc->stage back to DROP_REFERENCE if we changed wc->stage
7113  * to UPDATE_BACKREF previously while processing the block.
7114  *
7115  * NOTE: return value 1 means we should stop walking up.
7116  */
7117 static noinline int walk_up_proc(struct btrfs_trans_handle *trans,
7118                                  struct btrfs_root *root,
7119                                  struct btrfs_path *path,
7120                                  struct walk_control *wc)
7121 {
7122         int ret;
7123         int level = wc->level;
7124         struct extent_buffer *eb = path->nodes[level];
7125         u64 parent = 0;
7126
7127         if (wc->stage == UPDATE_BACKREF) {
7128                 BUG_ON(wc->shared_level < level);
7129                 if (level < wc->shared_level)
7130                         goto out;
7131
7132                 ret = find_next_key(path, level + 1, &wc->update_progress);
7133                 if (ret > 0)
7134                         wc->update_ref = 0;
7135
7136                 wc->stage = DROP_REFERENCE;
7137                 wc->shared_level = -1;
7138                 path->slots[level] = 0;
7139
7140                 /*
7141                  * check reference count again if the block isn't locked.
7142                  * we should start walking down the tree again if reference
7143                  * count is one.
7144                  */
7145                 if (!path->locks[level]) {
7146                         BUG_ON(level == 0);
7147                         btrfs_tree_lock(eb);
7148                         btrfs_set_lock_blocking(eb);
7149                         path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
7150
7151                         ret = btrfs_lookup_extent_info(trans, root,
7152                                                        eb->start, level, 1,
7153                                                        &wc->refs[level],
7154                                                        &wc->flags[level]);
7155                         if (ret < 0) {
7156                                 btrfs_tree_unlock_rw(eb, path->locks[level]);
7157                                 path->locks[level] = 0;
7158                                 return ret;
7159                         }
7160                         BUG_ON(wc->refs[level] == 0);
7161                         if (wc->refs[level] == 1) {
7162                                 btrfs_tree_unlock_rw(eb, path->locks[level]);
7163                                 path->locks[level] = 0;
7164                                 return 1;
7165                         }
7166                 }
7167         }
7168
7169         /* wc->stage == DROP_REFERENCE */
7170         BUG_ON(wc->refs[level] > 1 && !path->locks[level]);
7171
7172         if (wc->refs[level] == 1) {
7173                 if (level == 0) {
7174                         if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
7175                                 ret = btrfs_dec_ref(trans, root, eb, 1,
7176                                                     wc->for_reloc);
7177                         else
7178                                 ret = btrfs_dec_ref(trans, root, eb, 0,
7179                                                     wc->for_reloc);
7180                         BUG_ON(ret); /* -ENOMEM */
7181                 }
7182                 /* make block locked assertion in clean_tree_block happy */
7183                 if (!path->locks[level] &&
7184                     btrfs_header_generation(eb) == trans->transid) {
7185                         btrfs_tree_lock(eb);
7186                         btrfs_set_lock_blocking(eb);
7187                         path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
7188                 }
7189                 clean_tree_block(trans, root, eb);
7190         }
7191
7192         if (eb == root->node) {
7193                 if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
7194                         parent = eb->start;
7195                 else
7196                         BUG_ON(root->root_key.objectid !=
7197                                btrfs_header_owner(eb));
7198         } else {
7199                 if (wc->flags[level + 1] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
7200                         parent = path->nodes[level + 1]->start;
7201                 else
7202                         BUG_ON(root->root_key.objectid !=
7203                                btrfs_header_owner(path->nodes[level + 1]));
7204         }
7205
7206         btrfs_free_tree_block(trans, root, eb, parent, wc->refs[level] == 1);
7207 out:
7208         wc->refs[level] = 0;
7209         wc->flags[level] = 0;
7210         return 0;
7211 }
7212
7213 static noinline int walk_down_tree(struct btrfs_trans_handle *trans,
7214                                    struct btrfs_root *root,
7215                                    struct btrfs_path *path,
7216                                    struct walk_control *wc)
7217 {
7218         int level = wc->level;
7219         int lookup_info = 1;
7220         int ret;
7221
7222         while (level >= 0) {
7223                 ret = walk_down_proc(trans, root, path, wc, lookup_info);
7224                 if (ret > 0)
7225                         break;
7226
7227                 if (level == 0)
7228                         break;
7229
7230                 if (path->slots[level] >=
7231                     btrfs_header_nritems(path->nodes[level]))
7232                         break;
7233
7234                 ret = do_walk_down(trans, root, path, wc, &lookup_info);
7235                 if (ret > 0) {
7236                         path->slots[level]++;
7237                         continue;
7238                 } else if (ret < 0)
7239                         return ret;
7240                 level = wc->level;
7241         }
7242         return 0;
7243 }
7244
7245 static noinline int walk_up_tree(struct btrfs_trans_handle *trans,
7246                                  struct btrfs_root *root,
7247                                  struct btrfs_path *path,
7248                                  struct walk_control *wc, int max_level)
7249 {
7250         int level = wc->level;
7251         int ret;
7252
7253         path->slots[level] = btrfs_header_nritems(path->nodes[level]);
7254         while (level < max_level && path->nodes[level]) {
7255                 wc->level = level;
7256                 if (path->slots[level] + 1 <
7257                     btrfs_header_nritems(path->nodes[level])) {
7258                         path->slots[level]++;
7259                         return 0;
7260                 } else {
7261                         ret = walk_up_proc(trans, root, path, wc);
7262                         if (ret > 0)
7263                                 return 0;
7264
7265                         if (path->locks[level]) {
7266                                 btrfs_tree_unlock_rw(path->nodes[level],
7267                                                      path->locks[level]);
7268                                 path->locks[level] = 0;
7269                         }
7270                         free_extent_buffer(path->nodes[level]);
7271                         path->nodes[level] = NULL;
7272                         level++;
7273                 }
7274         }
7275         return 1;
7276 }
7277
7278 /*
7279  * drop a subvolume tree.
7280  *
7281  * this function traverses the tree freeing any blocks that only
7282  * referenced by the tree.
7283  *
7284  * when a shared tree block is found. this function decreases its
7285  * reference count by one. if update_ref is true, this function
7286  * also make sure backrefs for the shared block and all lower level
7287  * blocks are properly updated.
7288  *
7289  * If called with for_reloc == 0, may exit early with -EAGAIN
7290  */
7291 int btrfs_drop_snapshot(struct btrfs_root *root,
7292                          struct btrfs_block_rsv *block_rsv, int update_ref,
7293                          int for_reloc)
7294 {
7295         struct btrfs_path *path;
7296         struct btrfs_trans_handle *trans;
7297         struct btrfs_root *tree_root = root->fs_info->tree_root;
7298         struct btrfs_root_item *root_item = &root->root_item;
7299         struct walk_control *wc;
7300         struct btrfs_key key;
7301         int err = 0;
7302         int ret;
7303         int level;
7304
7305         path = btrfs_alloc_path();
7306         if (!path) {
7307                 err = -ENOMEM;
7308                 goto out;
7309         }
7310
7311         wc = kzalloc(sizeof(*wc), GFP_NOFS);
7312         if (!wc) {
7313                 btrfs_free_path(path);
7314                 err = -ENOMEM;
7315                 goto out;
7316         }
7317
7318         trans = btrfs_start_transaction(tree_root, 0);
7319         if (IS_ERR(trans)) {
7320                 err = PTR_ERR(trans);
7321                 goto out_free;
7322         }
7323
7324         if (block_rsv)
7325                 trans->block_rsv = block_rsv;
7326
7327         if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
7328                 level = btrfs_header_level(root->node);
7329                 path->nodes[level] = btrfs_lock_root_node(root);
7330                 btrfs_set_lock_blocking(path->nodes[level]);
7331                 path->slots[level] = 0;
7332                 path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
7333                 memset(&wc->update_progress, 0,
7334                        sizeof(wc->update_progress));
7335         } else {
7336                 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
7337                 memcpy(&wc->update_progress, &key,
7338                        sizeof(wc->update_progress));
7339
7340                 level = root_item->drop_level;
7341                 BUG_ON(level == 0);
7342                 path->lowest_level = level;
7343                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
7344                 path->lowest_level = 0;
7345                 if (ret < 0) {
7346                         err = ret;
7347                         goto out_end_trans;
7348                 }
7349                 WARN_ON(ret > 0);
7350
7351                 /*
7352                  * unlock our path, this is safe because only this
7353                  * function is allowed to delete this snapshot
7354                  */
7355                 btrfs_unlock_up_safe(path, 0);
7356
7357                 level = btrfs_header_level(root->node);
7358                 while (1) {
7359                         btrfs_tree_lock(path->nodes[level]);
7360                         btrfs_set_lock_blocking(path->nodes[level]);
7361
7362                         ret = btrfs_lookup_extent_info(trans, root,
7363                                                 path->nodes[level]->start,
7364                                                 level, 1, &wc->refs[level],
7365                                                 &wc->flags[level]);
7366                         if (ret < 0) {
7367                                 err = ret;
7368                                 goto out_end_trans;
7369                         }
7370                         BUG_ON(wc->refs[level] == 0);
7371
7372                         if (level == root_item->drop_level)
7373                                 break;
7374
7375                         btrfs_tree_unlock(path->nodes[level]);
7376                         WARN_ON(wc->refs[level] != 1);
7377                         level--;
7378                 }
7379         }
7380
7381         wc->level = level;
7382         wc->shared_level = -1;
7383         wc->stage = DROP_REFERENCE;
7384         wc->update_ref = update_ref;
7385         wc->keep_locks = 0;
7386         wc->for_reloc = for_reloc;
7387         wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(root);
7388
7389         while (1) {
7390                 if (!for_reloc && btrfs_fs_closing(root->fs_info)) {
7391                         pr_debug("btrfs: drop snapshot early exit\n");
7392                         err = -EAGAIN;
7393                         goto out_end_trans;
7394                 }
7395
7396                 ret = walk_down_tree(trans, root, path, wc);
7397                 if (ret < 0) {
7398                         err = ret;
7399                         break;
7400                 }
7401
7402                 ret = walk_up_tree(trans, root, path, wc, BTRFS_MAX_LEVEL);
7403                 if (ret < 0) {
7404                         err = ret;
7405                         break;
7406                 }
7407
7408                 if (ret > 0) {
7409                         BUG_ON(wc->stage != DROP_REFERENCE);
7410                         break;
7411                 }
7412
7413                 if (wc->stage == DROP_REFERENCE) {
7414                         level = wc->level;
7415                         btrfs_node_key(path->nodes[level],
7416                                        &root_item->drop_progress,
7417                                        path->slots[level]);
7418                         root_item->drop_level = level;
7419                 }
7420
7421                 BUG_ON(wc->level == 0);
7422                 if (btrfs_should_end_transaction(trans, tree_root)) {
7423                         ret = btrfs_update_root(trans, tree_root,
7424                                                 &root->root_key,
7425                                                 root_item);
7426                         if (ret) {
7427                                 btrfs_abort_transaction(trans, tree_root, ret);
7428                                 err = ret;
7429                                 goto out_end_trans;
7430                         }
7431
7432                         btrfs_end_transaction_throttle(trans, tree_root);
7433                         trans = btrfs_start_transaction(tree_root, 0);
7434                         if (IS_ERR(trans)) {
7435                                 err = PTR_ERR(trans);
7436                                 goto out_free;
7437                         }
7438                         if (block_rsv)
7439                                 trans->block_rsv = block_rsv;
7440                 }
7441         }
7442         btrfs_release_path(path);
7443         if (err)
7444                 goto out_end_trans;
7445
7446         ret = btrfs_del_root(trans, tree_root, &root->root_key);
7447         if (ret) {
7448                 btrfs_abort_transaction(trans, tree_root, ret);
7449                 goto out_end_trans;
7450         }
7451
7452         if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
7453                 ret = btrfs_find_last_root(tree_root, root->root_key.objectid,
7454                                            NULL, NULL);
7455                 if (ret < 0) {
7456                         btrfs_abort_transaction(trans, tree_root, ret);
7457                         err = ret;
7458                         goto out_end_trans;
7459                 } else if (ret > 0) {
7460                         /* if we fail to delete the orphan item this time
7461                          * around, it'll get picked up the next time.
7462                          *
7463                          * The most common failure here is just -ENOENT.
7464                          */
7465                         btrfs_del_orphan_item(trans, tree_root,
7466                                               root->root_key.objectid);
7467                 }
7468         }
7469
7470         if (root->in_radix) {
7471                 btrfs_free_fs_root(tree_root->fs_info, root);
7472         } else {
7473                 free_extent_buffer(root->node);
7474                 free_extent_buffer(root->commit_root);
7475                 kfree(root);
7476         }
7477 out_end_trans:
7478         btrfs_end_transaction_throttle(trans, tree_root);
7479 out_free:
7480         kfree(wc);
7481         btrfs_free_path(path);
7482 out:
7483         if (err)
7484                 btrfs_std_error(root->fs_info, err);
7485         return err;
7486 }
7487
7488 /*
7489  * drop subtree rooted at tree block 'node'.
7490  *
7491  * NOTE: this function will unlock and release tree block 'node'
7492  * only used by relocation code
7493  */
7494 int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
7495                         struct btrfs_root *root,
7496                         struct extent_buffer *node,
7497                         struct extent_buffer *parent)
7498 {
7499         struct btrfs_path *path;
7500         struct walk_control *wc;
7501         int level;
7502         int parent_level;
7503         int ret = 0;
7504         int wret;
7505
7506         BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);
7507
7508         path = btrfs_alloc_path();
7509         if (!path)
7510                 return -ENOMEM;
7511
7512         wc = kzalloc(sizeof(*wc), GFP_NOFS);
7513         if (!wc) {
7514                 btrfs_free_path(path);
7515                 return -ENOMEM;
7516         }
7517
7518         btrfs_assert_tree_locked(parent);
7519         parent_level = btrfs_header_level(parent);
7520         extent_buffer_get(parent);
7521         path->nodes[parent_level] = parent;
7522         path->slots[parent_level] = btrfs_header_nritems(parent);
7523
7524         btrfs_assert_tree_locked(node);
7525         level = btrfs_header_level(node);
7526         path->nodes[level] = node;
7527         path->slots[level] = 0;
7528         path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
7529
7530         wc->refs[parent_level] = 1;
7531         wc->flags[parent_level] = BTRFS_BLOCK_FLAG_FULL_BACKREF;
7532         wc->level = level;
7533         wc->shared_level = -1;
7534         wc->stage = DROP_REFERENCE;
7535         wc->update_ref = 0;
7536         wc->keep_locks = 1;
7537         wc->for_reloc = 1;
7538         wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(root);
7539
7540         while (1) {
7541                 wret = walk_down_tree(trans, root, path, wc);
7542                 if (wret < 0) {
7543                         ret = wret;
7544                         break;
7545                 }
7546
7547                 wret = walk_up_tree(trans, root, path, wc, parent_level);
7548                 if (wret < 0)
7549                         ret = wret;
7550                 if (wret != 0)
7551                         break;
7552         }
7553
7554         kfree(wc);
7555         btrfs_free_path(path);
7556         return ret;
7557 }
7558
7559 static u64 update_block_group_flags(struct btrfs_root *root, u64 flags)
7560 {
7561         u64 num_devices;
7562         u64 stripped;
7563
7564         /*
7565          * if restripe for this chunk_type is on pick target profile and
7566          * return, otherwise do the usual balance
7567          */
7568         stripped = get_restripe_target(root->fs_info, flags);
7569         if (stripped)
7570                 return extended_to_chunk(stripped);
7571
7572         /*
7573          * we add in the count of missing devices because we want
7574          * to make sure that any RAID levels on a degraded FS
7575          * continue to be honored.
7576          */
7577         num_devices = root->fs_info->fs_devices->rw_devices +
7578                 root->fs_info->fs_devices->missing_devices;
7579
7580         stripped = BTRFS_BLOCK_GROUP_RAID0 |
7581                 BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6 |
7582                 BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10;
7583
7584         if (num_devices == 1) {
7585                 stripped |= BTRFS_BLOCK_GROUP_DUP;
7586                 stripped = flags & ~stripped;
7587
7588                 /* turn raid0 into single device chunks */
7589                 if (flags & BTRFS_BLOCK_GROUP_RAID0)
7590                         return stripped;
7591
7592                 /* turn mirroring into duplication */
7593                 if (flags & (BTRFS_BLOCK_GROUP_RAID1 |
7594                              BTRFS_BLOCK_GROUP_RAID10))
7595                         return stripped | BTRFS_BLOCK_GROUP_DUP;
7596         } else {
7597                 /* they already had raid on here, just return */
7598                 if (flags & stripped)
7599                         return flags;
7600
7601                 stripped |= BTRFS_BLOCK_GROUP_DUP;
7602                 stripped = flags & ~stripped;
7603
7604                 /* switch duplicated blocks with raid1 */
7605                 if (flags & BTRFS_BLOCK_GROUP_DUP)
7606                         return stripped | BTRFS_BLOCK_GROUP_RAID1;
7607
7608                 /* this is drive concat, leave it alone */
7609         }
7610
7611         return flags;
7612 }
7613
7614 static int set_block_group_ro(struct btrfs_block_group_cache *cache, int force)
7615 {
7616         struct btrfs_space_info *sinfo = cache->space_info;
7617         u64 num_bytes;
7618         u64 min_allocable_bytes;
7619         int ret = -ENOSPC;
7620
7621
7622         /*
7623          * We need some metadata space and system metadata space for
7624          * allocating chunks in some corner cases until we force to set
7625          * it to be readonly.
7626          */
7627         if ((sinfo->flags &
7628              (BTRFS_BLOCK_GROUP_SYSTEM | BTRFS_BLOCK_GROUP_METADATA)) &&
7629             !force)
7630                 min_allocable_bytes = 1 * 1024 * 1024;
7631         else
7632                 min_allocable_bytes = 0;
7633
7634         spin_lock(&sinfo->lock);
7635         spin_lock(&cache->lock);
7636
7637         if (cache->ro) {
7638                 ret = 0;
7639                 goto out;
7640         }
7641
7642         num_bytes = cache->key.offset - cache->reserved - cache->pinned -
7643                     cache->bytes_super - btrfs_block_group_used(&cache->item);
7644
7645         if (sinfo->bytes_used + sinfo->bytes_reserved + sinfo->bytes_pinned +
7646             sinfo->bytes_may_use + sinfo->bytes_readonly + num_bytes +
7647             min_allocable_bytes <= sinfo->total_bytes) {
7648                 sinfo->bytes_readonly += num_bytes;
7649                 cache->ro = 1;
7650                 ret = 0;
7651         }
7652 out:
7653         spin_unlock(&cache->lock);
7654         spin_unlock(&sinfo->lock);
7655         return ret;
7656 }
7657
7658 int btrfs_set_block_group_ro(struct btrfs_root *root,
7659                              struct btrfs_block_group_cache *cache)
7660
7661 {
7662         struct btrfs_trans_handle *trans;
7663         u64 alloc_flags;
7664         int ret;
7665
7666         BUG_ON(cache->ro);
7667
7668         trans = btrfs_join_transaction(root);
7669         if (IS_ERR(trans))
7670                 return PTR_ERR(trans);
7671
7672         alloc_flags = update_block_group_flags(root, cache->flags);
7673         if (alloc_flags != cache->flags) {
7674                 ret = do_chunk_alloc(trans, root, alloc_flags,
7675                                      CHUNK_ALLOC_FORCE);
7676                 if (ret < 0)
7677                         goto out;
7678         }
7679
7680         ret = set_block_group_ro(cache, 0);
7681         if (!ret)
7682                 goto out;
7683         alloc_flags = get_alloc_profile(root, cache->space_info->flags);
7684         ret = do_chunk_alloc(trans, root, alloc_flags,
7685                              CHUNK_ALLOC_FORCE);
7686         if (ret < 0)
7687                 goto out;
7688         ret = set_block_group_ro(cache, 0);
7689 out:
7690         btrfs_end_transaction(trans, root);
7691         return ret;
7692 }
7693
7694 int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
7695                             struct btrfs_root *root, u64 type)
7696 {
7697         u64 alloc_flags = get_alloc_profile(root, type);
7698         return do_chunk_alloc(trans, root, alloc_flags,
7699                               CHUNK_ALLOC_FORCE);
7700 }
7701
7702 /*
7703  * helper to account the unused space of all the readonly block group in the
7704  * list. takes mirrors into account.
7705  */
7706 static u64 __btrfs_get_ro_block_group_free_space(struct list_head *groups_list)
7707 {
7708         struct btrfs_block_group_cache *block_group;
7709         u64 free_bytes = 0;
7710         int factor;
7711
7712         list_for_each_entry(block_group, groups_list, list) {
7713                 spin_lock(&block_group->lock);
7714
7715                 if (!block_group->ro) {
7716                         spin_unlock(&block_group->lock);
7717                         continue;
7718                 }
7719
7720                 if (block_group->flags & (BTRFS_BLOCK_GROUP_RAID1 |
7721                                           BTRFS_BLOCK_GROUP_RAID10 |
7722                                           BTRFS_BLOCK_GROUP_DUP))
7723                         factor = 2;
7724                 else
7725                         factor = 1;
7726
7727                 free_bytes += (block_group->key.offset -
7728                                btrfs_block_group_used(&block_group->item)) *
7729                                factor;
7730
7731                 spin_unlock(&block_group->lock);
7732         }
7733
7734         return free_bytes;
7735 }
7736
7737 /*
7738  * helper to account the unused space of all the readonly block group in the
7739  * space_info. takes mirrors into account.
7740  */
7741 u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo)
7742 {
7743         int i;
7744         u64 free_bytes = 0;
7745
7746         spin_lock(&sinfo->lock);
7747
7748         for(i = 0; i < BTRFS_NR_RAID_TYPES; i++)
7749                 if (!list_empty(&sinfo->block_groups[i]))
7750                         free_bytes += __btrfs_get_ro_block_group_free_space(
7751                                                 &sinfo->block_groups[i]);
7752
7753         spin_unlock(&sinfo->lock);
7754
7755         return free_bytes;
7756 }
7757
7758 void btrfs_set_block_group_rw(struct btrfs_root *root,
7759                               struct btrfs_block_group_cache *cache)
7760 {
7761         struct btrfs_space_info *sinfo = cache->space_info;
7762         u64 num_bytes;
7763
7764         BUG_ON(!cache->ro);
7765
7766         spin_lock(&sinfo->lock);
7767         spin_lock(&cache->lock);
7768         num_bytes = cache->key.offset - cache->reserved - cache->pinned -
7769                     cache->bytes_super - btrfs_block_group_used(&cache->item);
7770         sinfo->bytes_readonly -= num_bytes;
7771         cache->ro = 0;
7772         spin_unlock(&cache->lock);
7773         spin_unlock(&sinfo->lock);
7774 }
7775
7776 /*
7777  * checks to see if its even possible to relocate this block group.
7778  *
7779  * @return - -1 if it's not a good idea to relocate this block group, 0 if its
7780  * ok to go ahead and try.
7781  */
7782 int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr)
7783 {
7784         struct btrfs_block_group_cache *block_group;
7785         struct btrfs_space_info *space_info;
7786         struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
7787         struct btrfs_device *device;
7788         u64 min_free;
7789         u64 dev_min = 1;
7790         u64 dev_nr = 0;
7791         u64 target;
7792         int index;
7793         int full = 0;
7794         int ret = 0;
7795
7796         block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
7797
7798         /* odd, couldn't find the block group, leave it alone */
7799         if (!block_group)
7800                 return -1;
7801
7802         min_free = btrfs_block_group_used(&block_group->item);
7803
7804         /* no bytes used, we're good */
7805         if (!min_free)
7806                 goto out;
7807
7808         space_info = block_group->space_info;
7809         spin_lock(&space_info->lock);
7810
7811         full = space_info->full;
7812
7813         /*
7814          * if this is the last block group we have in this space, we can't
7815          * relocate it unless we're able to allocate a new chunk below.
7816          *
7817          * Otherwise, we need to make sure we have room in the space to handle
7818          * all of the extents from this block group.  If we can, we're good
7819          */
7820         if ((space_info->total_bytes != block_group->key.offset) &&
7821             (space_info->bytes_used + space_info->bytes_reserved +
7822              space_info->bytes_pinned + space_info->bytes_readonly +
7823              min_free < space_info->total_bytes)) {
7824                 spin_unlock(&space_info->lock);
7825                 goto out;
7826         }
7827         spin_unlock(&space_info->lock);
7828
7829         /*
7830          * ok we don't have enough space, but maybe we have free space on our
7831          * devices to allocate new chunks for relocation, so loop through our
7832          * alloc devices and guess if we have enough space.  if this block
7833          * group is going to be restriped, run checks against the target
7834          * profile instead of the current one.
7835          */
7836         ret = -1;
7837
7838         /*
7839          * index:
7840          *      0: raid10
7841          *      1: raid1
7842          *      2: dup
7843          *      3: raid0
7844          *      4: single
7845          */
7846         target = get_restripe_target(root->fs_info, block_group->flags);
7847         if (target) {
7848                 index = __get_raid_index(extended_to_chunk(target));
7849         } else {
7850                 /*
7851                  * this is just a balance, so if we were marked as full
7852                  * we know there is no space for a new chunk
7853                  */
7854                 if (full)
7855                         goto out;
7856
7857                 index = get_block_group_index(block_group);
7858         }
7859
7860         if (index == BTRFS_RAID_RAID10) {
7861                 dev_min = 4;
7862                 /* Divide by 2 */
7863                 min_free >>= 1;
7864         } else if (index == BTRFS_RAID_RAID1) {
7865                 dev_min = 2;
7866         } else if (index == BTRFS_RAID_DUP) {
7867                 /* Multiply by 2 */
7868                 min_free <<= 1;
7869         } else if (index == BTRFS_RAID_RAID0) {
7870                 dev_min = fs_devices->rw_devices;
7871                 do_div(min_free, dev_min);
7872         }
7873
7874         mutex_lock(&root->fs_info->chunk_mutex);
7875         list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) {
7876                 u64 dev_offset;
7877
7878                 /*
7879                  * check to make sure we can actually find a chunk with enough
7880                  * space to fit our block group in.
7881                  */
7882                 if (device->total_bytes > device->bytes_used + min_free &&
7883                     !device->is_tgtdev_for_dev_replace) {
7884                         ret = find_free_dev_extent(device, min_free,
7885                                                    &dev_offset, NULL);
7886                         if (!ret)
7887                                 dev_nr++;
7888
7889                         if (dev_nr >= dev_min)
7890                                 break;
7891
7892                         ret = -1;
7893                 }
7894         }
7895         mutex_unlock(&root->fs_info->chunk_mutex);
7896 out:
7897         btrfs_put_block_group(block_group);
7898         return ret;
7899 }
7900
7901 static int find_first_block_group(struct btrfs_root *root,
7902                 struct btrfs_path *path, struct btrfs_key *key)
7903 {
7904         int ret = 0;
7905         struct btrfs_key found_key;
7906         struct extent_buffer *leaf;
7907         int slot;
7908
7909         ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
7910         if (ret < 0)
7911                 goto out;
7912
7913         while (1) {
7914                 slot = path->slots[0];
7915                 leaf = path->nodes[0];
7916                 if (slot >= btrfs_header_nritems(leaf)) {
7917                         ret = btrfs_next_leaf(root, path);
7918                         if (ret == 0)
7919                                 continue;
7920                         if (ret < 0)
7921                                 goto out;
7922                         break;
7923                 }
7924                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
7925
7926                 if (found_key.objectid >= key->objectid &&
7927                     found_key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
7928                         ret = 0;
7929                         goto out;
7930                 }
7931                 path->slots[0]++;
7932         }
7933 out:
7934         return ret;
7935 }
7936
7937 void btrfs_put_block_group_cache(struct btrfs_fs_info *info)
7938 {
7939         struct btrfs_block_group_cache *block_group;
7940         u64 last = 0;
7941
7942         while (1) {
7943                 struct inode *inode;
7944
7945                 block_group = btrfs_lookup_first_block_group(info, last);
7946                 while (block_group) {
7947                         spin_lock(&block_group->lock);
7948                         if (block_group->iref)
7949                                 break;
7950                         spin_unlock(&block_group->lock);
7951                         block_group = next_block_group(info->tree_root,
7952                                                        block_group);
7953                 }
7954                 if (!block_group) {
7955                         if (last == 0)
7956                                 break;
7957                         last = 0;
7958                         continue;
7959                 }
7960
7961                 inode = block_group->inode;
7962                 block_group->iref = 0;
7963                 block_group->inode = NULL;
7964                 spin_unlock(&block_group->lock);
7965                 iput(inode);
7966                 last = block_group->key.objectid + block_group->key.offset;
7967                 btrfs_put_block_group(block_group);
7968         }
7969 }
7970
7971 int btrfs_free_block_groups(struct btrfs_fs_info *info)
7972 {
7973         struct btrfs_block_group_cache *block_group;
7974         struct btrfs_space_info *space_info;
7975         struct btrfs_caching_control *caching_ctl;
7976         struct rb_node *n;
7977
7978         down_write(&info->extent_commit_sem);
7979         while (!list_empty(&info->caching_block_groups)) {
7980                 caching_ctl = list_entry(info->caching_block_groups.next,
7981                                          struct btrfs_caching_control, list);
7982                 list_del(&caching_ctl->list);
7983                 put_caching_control(caching_ctl);
7984         }
7985         up_write(&info->extent_commit_sem);
7986
7987         spin_lock(&info->block_group_cache_lock);
7988         while ((n = rb_last(&info->block_group_cache_tree)) != NULL) {
7989                 block_group = rb_entry(n, struct btrfs_block_group_cache,
7990                                        cache_node);
7991                 rb_erase(&block_group->cache_node,
7992                          &info->block_group_cache_tree);
7993                 spin_unlock(&info->block_group_cache_lock);
7994
7995                 down_write(&block_group->space_info->groups_sem);
7996                 list_del(&block_group->list);
7997                 up_write(&block_group->space_info->groups_sem);
7998
7999                 if (block_group->cached == BTRFS_CACHE_STARTED)
8000                         wait_block_group_cache_done(block_group);
8001
8002                 /*
8003                  * We haven't cached this block group, which means we could
8004                  * possibly have excluded extents on this block group.
8005                  */
8006                 if (block_group->cached == BTRFS_CACHE_NO)
8007                         free_excluded_extents(info->extent_root, block_group);
8008
8009                 btrfs_remove_free_space_cache(block_group);
8010                 btrfs_put_block_group(block_group);
8011
8012                 spin_lock(&info->block_group_cache_lock);
8013         }
8014         spin_unlock(&info->block_group_cache_lock);
8015
8016         /* now that all the block groups are freed, go through and
8017          * free all the space_info structs.  This is only called during
8018          * the final stages of unmount, and so we know nobody is
8019          * using them.  We call synchronize_rcu() once before we start,
8020          * just to be on the safe side.
8021          */
8022         synchronize_rcu();
8023
8024         release_global_block_rsv(info);
8025
8026         while(!list_empty(&info->space_info)) {
8027                 space_info = list_entry(info->space_info.next,
8028                                         struct btrfs_space_info,
8029                                         list);
8030                 if (btrfs_test_opt(info->tree_root, ENOSPC_DEBUG)) {
8031                         if (space_info->bytes_pinned > 0 ||
8032                             space_info->bytes_reserved > 0 ||
8033                             space_info->bytes_may_use > 0) {
8034                                 WARN_ON(1);
8035                                 dump_space_info(space_info, 0, 0);
8036                         }
8037                 }
8038                 list_del(&space_info->list);
8039                 kfree(space_info);
8040         }
8041         return 0;
8042 }
8043
8044 static void __link_block_group(struct btrfs_space_info *space_info,
8045                                struct btrfs_block_group_cache *cache)
8046 {
8047         int index = get_block_group_index(cache);
8048
8049         down_write(&space_info->groups_sem);
8050         list_add_tail(&cache->list, &space_info->block_groups[index]);
8051         up_write(&space_info->groups_sem);
8052 }
8053
8054 int btrfs_read_block_groups(struct btrfs_root *root)
8055 {
8056         struct btrfs_path *path;
8057         int ret;
8058         struct btrfs_block_group_cache *cache;
8059         struct btrfs_fs_info *info = root->fs_info;
8060         struct btrfs_space_info *space_info;
8061         struct btrfs_key key;
8062         struct btrfs_key found_key;
8063         struct extent_buffer *leaf;
8064         int need_clear = 0;
8065         u64 cache_gen;
8066
8067         root = info->extent_root;
8068         key.objectid = 0;
8069         key.offset = 0;
8070         btrfs_set_key_type(&key, BTRFS_BLOCK_GROUP_ITEM_KEY);
8071         path = btrfs_alloc_path();
8072         if (!path)
8073                 return -ENOMEM;
8074         path->reada = 1;
8075
8076         cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
8077         if (btrfs_test_opt(root, SPACE_CACHE) &&
8078             btrfs_super_generation(root->fs_info->super_copy) != cache_gen)
8079                 need_clear = 1;
8080         if (btrfs_test_opt(root, CLEAR_CACHE))
8081                 need_clear = 1;
8082
8083         while (1) {
8084                 ret = find_first_block_group(root, path, &key);
8085                 if (ret > 0)
8086                         break;
8087                 if (ret != 0)
8088                         goto error;
8089                 leaf = path->nodes[0];
8090                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
8091                 cache = kzalloc(sizeof(*cache), GFP_NOFS);
8092                 if (!cache) {
8093                         ret = -ENOMEM;
8094                         goto error;
8095                 }
8096                 cache->free_space_ctl = kzalloc(sizeof(*cache->free_space_ctl),
8097                                                 GFP_NOFS);
8098                 if (!cache->free_space_ctl) {
8099                         kfree(cache);
8100                         ret = -ENOMEM;
8101                         goto error;
8102                 }
8103
8104                 atomic_set(&cache->count, 1);
8105                 spin_lock_init(&cache->lock);
8106                 cache->fs_info = info;
8107                 INIT_LIST_HEAD(&cache->list);
8108                 INIT_LIST_HEAD(&cache->cluster_list);
8109
8110                 if (need_clear) {
8111                         /*
8112                          * When we mount with old space cache, we need to
8113                          * set BTRFS_DC_CLEAR and set dirty flag.
8114                          *
8115                          * a) Setting 'BTRFS_DC_CLEAR' makes sure that we
8116                          *    truncate the old free space cache inode and
8117                          *    setup a new one.
8118                          * b) Setting 'dirty flag' makes sure that we flush
8119                          *    the new space cache info onto disk.
8120                          */
8121                         cache->disk_cache_state = BTRFS_DC_CLEAR;
8122                         if (btrfs_test_opt(root, SPACE_CACHE))
8123                                 cache->dirty = 1;
8124                 }
8125
8126                 read_extent_buffer(leaf, &cache->item,
8127                                    btrfs_item_ptr_offset(leaf, path->slots[0]),
8128                                    sizeof(cache->item));
8129                 memcpy(&cache->key, &found_key, sizeof(found_key));
8130
8131                 key.objectid = found_key.objectid + found_key.offset;
8132                 btrfs_release_path(path);
8133                 cache->flags = btrfs_block_group_flags(&cache->item);
8134                 cache->sectorsize = root->sectorsize;
8135                 cache->full_stripe_len = btrfs_full_stripe_len(root,
8136                                                &root->fs_info->mapping_tree,
8137                                                found_key.objectid);
8138                 btrfs_init_free_space_ctl(cache);
8139
8140                 /*
8141                  * We need to exclude the super stripes now so that the space
8142                  * info has super bytes accounted for, otherwise we'll think
8143                  * we have more space than we actually do.
8144                  */
8145                 ret = exclude_super_stripes(root, cache);
8146                 if (ret) {
8147                         /*
8148                          * We may have excluded something, so call this just in
8149                          * case.
8150                          */
8151                         free_excluded_extents(root, cache);
8152                         kfree(cache->free_space_ctl);
8153                         kfree(cache);
8154                         goto error;
8155                 }
8156
8157                 /*
8158                  * check for two cases, either we are full, and therefore
8159                  * don't need to bother with the caching work since we won't
8160                  * find any space, or we are empty, and we can just add all
8161                  * the space in and be done with it.  This saves us _alot_ of
8162                  * time, particularly in the full case.
8163                  */
8164                 if (found_key.offset == btrfs_block_group_used(&cache->item)) {
8165                         cache->last_byte_to_unpin = (u64)-1;
8166                         cache->cached = BTRFS_CACHE_FINISHED;
8167                         free_excluded_extents(root, cache);
8168                 } else if (btrfs_block_group_used(&cache->item) == 0) {
8169                         cache->last_byte_to_unpin = (u64)-1;
8170                         cache->cached = BTRFS_CACHE_FINISHED;
8171                         add_new_free_space(cache, root->fs_info,
8172                                            found_key.objectid,
8173                                            found_key.objectid +
8174                                            found_key.offset);
8175                         free_excluded_extents(root, cache);
8176                 }
8177
8178                 ret = btrfs_add_block_group_cache(root->fs_info, cache);
8179                 if (ret) {
8180                         btrfs_remove_free_space_cache(cache);
8181                         btrfs_put_block_group(cache);
8182                         goto error;
8183                 }
8184
8185                 ret = update_space_info(info, cache->flags, found_key.offset,
8186                                         btrfs_block_group_used(&cache->item),
8187                                         &space_info);
8188                 if (ret) {
8189                         btrfs_remove_free_space_cache(cache);
8190                         spin_lock(&info->block_group_cache_lock);
8191                         rb_erase(&cache->cache_node,
8192                                  &info->block_group_cache_tree);
8193                         spin_unlock(&info->block_group_cache_lock);
8194                         btrfs_put_block_group(cache);
8195                         goto error;
8196                 }
8197
8198                 cache->space_info = space_info;
8199                 spin_lock(&cache->space_info->lock);
8200                 cache->space_info->bytes_readonly += cache->bytes_super;
8201                 spin_unlock(&cache->space_info->lock);
8202
8203                 __link_block_group(space_info, cache);
8204
8205                 set_avail_alloc_bits(root->fs_info, cache->flags);
8206                 if (btrfs_chunk_readonly(root, cache->key.objectid))
8207                         set_block_group_ro(cache, 1);
8208         }
8209
8210         list_for_each_entry_rcu(space_info, &root->fs_info->space_info, list) {
8211                 if (!(get_alloc_profile(root, space_info->flags) &
8212                       (BTRFS_BLOCK_GROUP_RAID10 |
8213                        BTRFS_BLOCK_GROUP_RAID1 |
8214                        BTRFS_BLOCK_GROUP_RAID5 |
8215                        BTRFS_BLOCK_GROUP_RAID6 |
8216                        BTRFS_BLOCK_GROUP_DUP)))
8217                         continue;
8218                 /*
8219                  * avoid allocating from un-mirrored block group if there are
8220                  * mirrored block groups.
8221                  */
8222                 list_for_each_entry(cache, &space_info->block_groups[3], list)
8223                         set_block_group_ro(cache, 1);
8224                 list_for_each_entry(cache, &space_info->block_groups[4], list)
8225                         set_block_group_ro(cache, 1);
8226         }
8227
8228         init_global_block_rsv(info);
8229         ret = 0;
8230 error:
8231         btrfs_free_path(path);
8232         return ret;
8233 }
8234
8235 void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans,
8236                                        struct btrfs_root *root)
8237 {
8238         struct btrfs_block_group_cache *block_group, *tmp;
8239         struct btrfs_root *extent_root = root->fs_info->extent_root;
8240         struct btrfs_block_group_item item;
8241         struct btrfs_key key;
8242         int ret = 0;
8243
8244         list_for_each_entry_safe(block_group, tmp, &trans->new_bgs,
8245                                  new_bg_list) {
8246                 list_del_init(&block_group->new_bg_list);
8247
8248                 if (ret)
8249                         continue;
8250
8251                 spin_lock(&block_group->lock);
8252                 memcpy(&item, &block_group->item, sizeof(item));
8253                 memcpy(&key, &block_group->key, sizeof(key));
8254                 spin_unlock(&block_group->lock);
8255
8256                 ret = btrfs_insert_item(trans, extent_root, &key, &item,
8257                                         sizeof(item));
8258                 if (ret)
8259                         btrfs_abort_transaction(trans, extent_root, ret);
8260         }
8261 }
8262
8263 int btrfs_make_block_group(struct btrfs_trans_handle *trans,
8264                            struct btrfs_root *root, u64 bytes_used,
8265                            u64 type, u64 chunk_objectid, u64 chunk_offset,
8266                            u64 size)
8267 {
8268         int ret;
8269         struct btrfs_root *extent_root;
8270         struct btrfs_block_group_cache *cache;
8271
8272         extent_root = root->fs_info->extent_root;
8273
8274         root->fs_info->last_trans_log_full_commit = trans->transid;
8275
8276         cache = kzalloc(sizeof(*cache), GFP_NOFS);
8277         if (!cache)
8278                 return -ENOMEM;
8279         cache->free_space_ctl = kzalloc(sizeof(*cache->free_space_ctl),
8280                                         GFP_NOFS);
8281         if (!cache->free_space_ctl) {
8282                 kfree(cache);
8283                 return -ENOMEM;
8284         }
8285
8286         cache->key.objectid = chunk_offset;
8287         cache->key.offset = size;
8288         cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
8289         cache->sectorsize = root->sectorsize;
8290         cache->fs_info = root->fs_info;
8291         cache->full_stripe_len = btrfs_full_stripe_len(root,
8292                                                &root->fs_info->mapping_tree,
8293                                                chunk_offset);
8294
8295         atomic_set(&cache->count, 1);
8296         spin_lock_init(&cache->lock);
8297         INIT_LIST_HEAD(&cache->list);
8298         INIT_LIST_HEAD(&cache->cluster_list);
8299         INIT_LIST_HEAD(&cache->new_bg_list);
8300
8301         btrfs_init_free_space_ctl(cache);
8302
8303         btrfs_set_block_group_used(&cache->item, bytes_used);
8304         btrfs_set_block_group_chunk_objectid(&cache->item, chunk_objectid);
8305         cache->flags = type;
8306         btrfs_set_block_group_flags(&cache->item, type);
8307
8308         cache->last_byte_to_unpin = (u64)-1;
8309         cache->cached = BTRFS_CACHE_FINISHED;
8310         ret = exclude_super_stripes(root, cache);
8311         if (ret) {
8312                 /*
8313                  * We may have excluded something, so call this just in
8314                  * case.
8315                  */
8316                 free_excluded_extents(root, cache);
8317                 kfree(cache->free_space_ctl);
8318                 kfree(cache);
8319                 return ret;
8320         }
8321
8322         add_new_free_space(cache, root->fs_info, chunk_offset,
8323                            chunk_offset + size);
8324
8325         free_excluded_extents(root, cache);
8326
8327         ret = btrfs_add_block_group_cache(root->fs_info, cache);
8328         if (ret) {
8329                 btrfs_remove_free_space_cache(cache);
8330                 btrfs_put_block_group(cache);
8331                 return ret;
8332         }
8333
8334         ret = update_space_info(root->fs_info, cache->flags, size, bytes_used,
8335                                 &cache->space_info);
8336         if (ret) {
8337                 btrfs_remove_free_space_cache(cache);
8338                 spin_lock(&root->fs_info->block_group_cache_lock);
8339                 rb_erase(&cache->cache_node,
8340                          &root->fs_info->block_group_cache_tree);
8341                 spin_unlock(&root->fs_info->block_group_cache_lock);
8342                 btrfs_put_block_group(cache);
8343                 return ret;
8344         }
8345         update_global_block_rsv(root->fs_info);
8346
8347         spin_lock(&cache->space_info->lock);
8348         cache->space_info->bytes_readonly += cache->bytes_super;
8349         spin_unlock(&cache->space_info->lock);
8350
8351         __link_block_group(cache->space_info, cache);
8352
8353         list_add_tail(&cache->new_bg_list, &trans->new_bgs);
8354
8355         set_avail_alloc_bits(extent_root->fs_info, type);
8356
8357         return 0;
8358 }
8359
8360 static void clear_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)
8361 {
8362         u64 extra_flags = chunk_to_extended(flags) &
8363                                 BTRFS_EXTENDED_PROFILE_MASK;
8364
8365         write_seqlock(&fs_info->profiles_lock);
8366         if (flags & BTRFS_BLOCK_GROUP_DATA)
8367                 fs_info->avail_data_alloc_bits &= ~extra_flags;
8368         if (flags & BTRFS_BLOCK_GROUP_METADATA)
8369                 fs_info->avail_metadata_alloc_bits &= ~extra_flags;
8370         if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
8371                 fs_info->avail_system_alloc_bits &= ~extra_flags;
8372         write_sequnlock(&fs_info->profiles_lock);
8373 }
8374
8375 int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
8376                              struct btrfs_root *root, u64 group_start)
8377 {
8378         struct btrfs_path *path;
8379         struct btrfs_block_group_cache *block_group;
8380         struct btrfs_free_cluster *cluster;
8381         struct btrfs_root *tree_root = root->fs_info->tree_root;
8382         struct btrfs_key key;
8383         struct inode *inode;
8384         int ret;
8385         int index;
8386         int factor;
8387
8388         root = root->fs_info->extent_root;
8389
8390         block_group = btrfs_lookup_block_group(root->fs_info, group_start);
8391         BUG_ON(!block_group);
8392         BUG_ON(!block_group->ro);
8393
8394         /*
8395          * Free the reserved super bytes from this block group before
8396          * remove it.
8397          */
8398         free_excluded_extents(root, block_group);
8399
8400         memcpy(&key, &block_group->key, sizeof(key));
8401         index = get_block_group_index(block_group);
8402         if (block_group->flags & (BTRFS_BLOCK_GROUP_DUP |
8403                                   BTRFS_BLOCK_GROUP_RAID1 |
8404                                   BTRFS_BLOCK_GROUP_RAID10))
8405                 factor = 2;
8406         else
8407                 factor = 1;
8408
8409         /* make sure this block group isn't part of an allocation cluster */
8410         cluster = &root->fs_info->data_alloc_cluster;
8411         spin_lock(&cluster->refill_lock);
8412         btrfs_return_cluster_to_free_space(block_group, cluster);
8413         spin_unlock(&cluster->refill_lock);
8414
8415         /*
8416          * make sure this block group isn't part of a metadata
8417          * allocation cluster
8418          */
8419         cluster = &root->fs_info->meta_alloc_cluster;
8420         spin_lock(&cluster->refill_lock);
8421         btrfs_return_cluster_to_free_space(block_group, cluster);
8422         spin_unlock(&cluster->refill_lock);
8423
8424         path = btrfs_alloc_path();
8425         if (!path) {
8426                 ret = -ENOMEM;
8427                 goto out;
8428         }
8429
8430         inode = lookup_free_space_inode(tree_root, block_group, path);
8431         if (!IS_ERR(inode)) {
8432                 ret = btrfs_orphan_add(trans, inode);
8433                 if (ret) {
8434                         btrfs_add_delayed_iput(inode);
8435                         goto out;
8436                 }
8437                 clear_nlink(inode);
8438                 /* One for the block groups ref */
8439                 spin_lock(&block_group->lock);
8440                 if (block_group->iref) {
8441                         block_group->iref = 0;
8442                         block_group->inode = NULL;
8443                         spin_unlock(&block_group->lock);
8444                         iput(inode);
8445                 } else {
8446                         spin_unlock(&block_group->lock);
8447                 }
8448                 /* One for our lookup ref */
8449                 btrfs_add_delayed_iput(inode);
8450         }
8451
8452         key.objectid = BTRFS_FREE_SPACE_OBJECTID;
8453         key.offset = block_group->key.objectid;
8454         key.type = 0;
8455
8456         ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);
8457         if (ret < 0)
8458                 goto out;
8459         if (ret > 0)
8460                 btrfs_release_path(path);
8461         if (ret == 0) {
8462                 ret = btrfs_del_item(trans, tree_root, path);
8463                 if (ret)
8464                         goto out;
8465                 btrfs_release_path(path);
8466         }
8467
8468         spin_lock(&root->fs_info->block_group_cache_lock);
8469         rb_erase(&block_group->cache_node,
8470                  &root->fs_info->block_group_cache_tree);
8471
8472         if (root->fs_info->first_logical_byte == block_group->key.objectid)
8473                 root->fs_info->first_logical_byte = (u64)-1;
8474         spin_unlock(&root->fs_info->block_group_cache_lock);
8475
8476         down_write(&block_group->space_info->groups_sem);
8477         /*
8478          * we must use list_del_init so people can check to see if they
8479          * are still on the list after taking the semaphore
8480          */
8481         list_del_init(&block_group->list);
8482         if (list_empty(&block_group->space_info->block_groups[index]))
8483                 clear_avail_alloc_bits(root->fs_info, block_group->flags);
8484         up_write(&block_group->space_info->groups_sem);
8485
8486         if (block_group->cached == BTRFS_CACHE_STARTED)
8487                 wait_block_group_cache_done(block_group);
8488
8489         btrfs_remove_free_space_cache(block_group);
8490
8491         spin_lock(&block_group->space_info->lock);
8492         block_group->space_info->total_bytes -= block_group->key.offset;
8493         block_group->space_info->bytes_readonly -= block_group->key.offset;
8494         block_group->space_info->disk_total -= block_group->key.offset * factor;
8495         spin_unlock(&block_group->space_info->lock);
8496
8497         memcpy(&key, &block_group->key, sizeof(key));
8498
8499         btrfs_clear_space_info_full(root->fs_info);
8500
8501         btrfs_put_block_group(block_group);
8502         btrfs_put_block_group(block_group);
8503
8504         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
8505         if (ret > 0)
8506                 ret = -EIO;
8507         if (ret < 0)
8508                 goto out;
8509
8510         ret = btrfs_del_item(trans, root, path);
8511 out:
8512         btrfs_free_path(path);
8513         return ret;
8514 }
8515
8516 int btrfs_init_space_info(struct btrfs_fs_info *fs_info)
8517 {
8518         struct btrfs_space_info *space_info;
8519         struct btrfs_super_block *disk_super;
8520         u64 features;
8521         u64 flags;
8522         int mixed = 0;
8523         int ret;
8524
8525         disk_super = fs_info->super_copy;
8526         if (!btrfs_super_root(disk_super))
8527                 return 1;
8528
8529         features = btrfs_super_incompat_flags(disk_super);
8530         if (features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)
8531                 mixed = 1;
8532
8533         flags = BTRFS_BLOCK_GROUP_SYSTEM;
8534         ret = update_space_info(fs_info, flags, 0, 0, &space_info);
8535         if (ret)
8536                 goto out;
8537
8538         if (mixed) {
8539                 flags = BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA;
8540                 ret = update_space_info(fs_info, flags, 0, 0, &space_info);
8541         } else {
8542                 flags = BTRFS_BLOCK_GROUP_METADATA;
8543                 ret = update_space_info(fs_info, flags, 0, 0, &space_info);
8544                 if (ret)
8545                         goto out;
8546
8547                 flags = BTRFS_BLOCK_GROUP_DATA;
8548                 ret = update_space_info(fs_info, flags, 0, 0, &space_info);
8549         }
8550 out:
8551         return ret;
8552 }
8553
8554 int btrfs_error_unpin_extent_range(struct btrfs_root *root, u64 start, u64 end)
8555 {
8556         return unpin_extent_range(root, start, end);
8557 }
8558
8559 int btrfs_error_discard_extent(struct btrfs_root *root, u64 bytenr,
8560                                u64 num_bytes, u64 *actual_bytes)
8561 {
8562         return btrfs_discard_extent(root, bytenr, num_bytes, actual_bytes);
8563 }
8564
8565 int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range)
8566 {
8567         struct btrfs_fs_info *fs_info = root->fs_info;
8568         struct btrfs_block_group_cache *cache = NULL;
8569         u64 group_trimmed;
8570         u64 start;
8571         u64 end;
8572         u64 trimmed = 0;
8573         u64 total_bytes = btrfs_super_total_bytes(fs_info->super_copy);
8574         int ret = 0;
8575
8576         /*
8577          * try to trim all FS space, our block group may start from non-zero.
8578          */
8579         if (range->len == total_bytes)
8580                 cache = btrfs_lookup_first_block_group(fs_info, range->start);
8581         else
8582                 cache = btrfs_lookup_block_group(fs_info, range->start);
8583
8584         while (cache) {
8585                 if (cache->key.objectid >= (range->start + range->len)) {
8586                         btrfs_put_block_group(cache);
8587                         break;
8588                 }
8589
8590                 start = max(range->start, cache->key.objectid);
8591                 end = min(range->start + range->len,
8592                                 cache->key.objectid + cache->key.offset);
8593
8594                 if (end - start >= range->minlen) {
8595                         if (!block_group_cache_done(cache)) {
8596                                 ret = cache_block_group(cache, 0);
8597                                 if (!ret)
8598                                         wait_block_group_cache_done(cache);
8599                         }
8600                         ret = btrfs_trim_block_group(cache,
8601                                                      &group_trimmed,
8602                                                      start,
8603                                                      end,
8604                                                      range->minlen);
8605
8606                         trimmed += group_trimmed;
8607                         if (ret) {
8608                                 btrfs_put_block_group(cache);
8609                                 break;
8610                         }
8611                 }
8612
8613                 cache = next_block_group(fs_info->tree_root, cache);
8614         }
8615
8616         range->len = trimmed;
8617         return ret;
8618 }