git.oblomov.eu Git - linux-2.6/blob - fs/btrfs/transaction.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
  19 #include <linux/fs.h>
  20 #include <linux/sched.h>
  21 #include <linux/writeback.h>
  22 #include <linux/pagemap.h>
  23 #include <linux/blkdev.h>
  24 #include "ctree.h"
  25 #include "disk-io.h"
  26 #include "transaction.h"
  27 #include "locking.h"
  28 #include "ref-cache.h"
  29 #include "tree-log.h"
  30
  31 #define BTRFS_ROOT_TRANS_TAG 0
  32
  33 static noinline void put_transaction(struct btrfs_transaction *transaction)
  34 {
  35         WARN_ON(transaction->use_count == 0);
  36         transaction->use_count--;
  37         if (transaction->use_count == 0) {
  38                 list_del_init(&transaction->list);
  39                 memset(transaction, 0, sizeof(*transaction));
  40                 kmem_cache_free(btrfs_transaction_cachep, transaction);
  41         }
  42 }
  43
  44 /*
  45  * either allocate a new transaction or hop into the existing one
  46  */
  47 static noinline int join_transaction(struct btrfs_root *root)
  48 {
  49         struct btrfs_transaction *cur_trans;
  50         cur_trans = root->fs_info->running_transaction;
  51         if (!cur_trans) {
  52                 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep,
  53                                              GFP_NOFS);
  54                 BUG_ON(!cur_trans);
  55                 root->fs_info->generation++;
  56                 root->fs_info->last_alloc = 0;
  57                 root->fs_info->last_data_alloc = 0;
  58                 cur_trans->num_writers = 1;
  59                 cur_trans->num_joined = 0;
  60                 cur_trans->transid = root->fs_info->generation;
  61                 init_waitqueue_head(&cur_trans->writer_wait);
  62                 init_waitqueue_head(&cur_trans->commit_wait);
  63                 cur_trans->in_commit = 0;
  64                 cur_trans->blocked = 0;
  65                 cur_trans->use_count = 1;
  66                 cur_trans->commit_done = 0;
  67                 cur_trans->start_time = get_seconds();
  68
  69                 cur_trans->delayed_refs.root.rb_node = NULL;
  70                 cur_trans->delayed_refs.num_entries = 0;
  71                 cur_trans->delayed_refs.num_heads_ready = 0;
  72                 cur_trans->delayed_refs.num_heads = 0;
  73                 cur_trans->delayed_refs.flushing = 0;
  74                 cur_trans->delayed_refs.run_delayed_start = 0;
  75                 spin_lock_init(&cur_trans->delayed_refs.lock);
  76
  77                 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
  78                 list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
  79                 extent_io_tree_init(&cur_trans->dirty_pages,
  80                                      root->fs_info->btree_inode->i_mapping,
  81                                      GFP_NOFS);
  82                 spin_lock(&root->fs_info->new_trans_lock);
  83                 root->fs_info->running_transaction = cur_trans;
  84                 spin_unlock(&root->fs_info->new_trans_lock);
  85         } else {
  86                 cur_trans->num_writers++;
  87                 cur_trans->num_joined++;
  88         }
  89
  90         return 0;
  91 }
  92
  93 /*
  94  * this does all the record keeping required to make sure that a reference
  95  * counted root is properly recorded in a given transaction.  This is required
  96  * to make sure the old root from before we joined the transaction is deleted
  97  * when the transaction commits
  98  */
  99 noinline int btrfs_record_root_in_trans(struct btrfs_root *root)
 100 {
 101         struct btrfs_dirty_root *dirty;
 102         u64 running_trans_id = root->fs_info->running_transaction->transid;
 103         if (root->ref_cows && root->last_trans < running_trans_id) {
 104                 WARN_ON(root == root->fs_info->extent_root);
 105                 if (root->root_item.refs != 0) {
 106                         radix_tree_tag_set(&root->fs_info->fs_roots_radix,
 107                                    (unsigned long)root->root_key.objectid,
 108                                    BTRFS_ROOT_TRANS_TAG);
 109
 110                         dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
 111                         BUG_ON(!dirty);
 112                         dirty->root = kmalloc(sizeof(*dirty->root), GFP_NOFS);
 113                         BUG_ON(!dirty->root);
 114                         dirty->latest_root = root;
 115                         INIT_LIST_HEAD(&dirty->list);
 116
 117                         root->commit_root = btrfs_root_node(root);
 118
 119                         memcpy(dirty->root, root, sizeof(*root));
 120                         spin_lock_init(&dirty->root->node_lock);
 121                         spin_lock_init(&dirty->root->list_lock);
 122                         mutex_init(&dirty->root->objectid_mutex);
 123                         mutex_init(&dirty->root->log_mutex);
 124                         INIT_LIST_HEAD(&dirty->root->dead_list);
 125                         dirty->root->node = root->commit_root;
 126                         dirty->root->commit_root = NULL;
 127
 128                         spin_lock(&root->list_lock);
 129                         list_add(&dirty->root->dead_list, &root->dead_list);
 130                         spin_unlock(&root->list_lock);
 131
 132                         root->dirty_root = dirty;
 133                 } else {
 134                         WARN_ON(1);
 135                 }
 136                 root->last_trans = running_trans_id;
 137         }
 138         return 0;
 139 }
 140
 141 /* wait for commit against the current transaction to become unblocked
 142  * when this is done, it is safe to start a new transaction, but the current
 143  * transaction might not be fully on disk.
 144  */
 145 static void wait_current_trans(struct btrfs_root *root)
 146 {
 147         struct btrfs_transaction *cur_trans;
 148
 149         cur_trans = root->fs_info->running_transaction;
 150         if (cur_trans && cur_trans->blocked) {
 151                 DEFINE_WAIT(wait);
 152                 cur_trans->use_count++;
 153                 while (1) {
 154                         prepare_to_wait(&root->fs_info->transaction_wait, &wait,
 155                                         TASK_UNINTERRUPTIBLE);
 156                         if (cur_trans->blocked) {
 157                                 mutex_unlock(&root->fs_info->trans_mutex);
 158                                 schedule();
 159                                 mutex_lock(&root->fs_info->trans_mutex);
 160                                 finish_wait(&root->fs_info->transaction_wait,
 161                                             &wait);
 162                         } else {
 163                                 finish_wait(&root->fs_info->transaction_wait,
 164                                             &wait);
 165                                 break;
 166                         }
 167                 }
 168                 put_transaction(cur_trans);
 169         }
 170 }
 171
 172 static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
 173                                              int num_blocks, int wait)
 174 {
 175         struct btrfs_trans_handle *h =
 176                 kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
 177         int ret;
 178
 179         mutex_lock(&root->fs_info->trans_mutex);
 180         if (!root->fs_info->log_root_recovering &&
 181             ((wait == 1 && !root->fs_info->open_ioctl_trans) || wait == 2))
 182                 wait_current_trans(root);
 183         ret = join_transaction(root);
 184         BUG_ON(ret);
 185
 186         btrfs_record_root_in_trans(root);
 187         h->transid = root->fs_info->running_transaction->transid;
 188         h->transaction = root->fs_info->running_transaction;
 189         h->blocks_reserved = num_blocks;
 190         h->blocks_used = 0;
 191         h->block_group = 0;
 192         h->alloc_exclude_nr = 0;
 193         h->alloc_exclude_start = 0;
 194         h->delayed_ref_updates = 0;
 195         root->fs_info->running_transaction->use_count++;
 196         mutex_unlock(&root->fs_info->trans_mutex);
 197         return h;
 198 }
 199
 200 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
 201                                                    int num_blocks)
 202 {
 203         return start_transaction(root, num_blocks, 1);
 204 }
 205 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root,
 206                                                    int num_blocks)
 207 {
 208         return start_transaction(root, num_blocks, 0);
 209 }
 210
 211 struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r,
 212                                                          int num_blocks)
 213 {
 214         return start_transaction(r, num_blocks, 2);
 215 }
 216
 217 /* wait for a transaction commit to be fully complete */
 218 static noinline int wait_for_commit(struct btrfs_root *root,
 219                                     struct btrfs_transaction *commit)
 220 {
 221         DEFINE_WAIT(wait);
 222         mutex_lock(&root->fs_info->trans_mutex);
 223         while (!commit->commit_done) {
 224                 prepare_to_wait(&commit->commit_wait, &wait,
 225                                 TASK_UNINTERRUPTIBLE);
 226                 if (commit->commit_done)
 227                         break;
 228                 mutex_unlock(&root->fs_info->trans_mutex);
 229                 schedule();
 230                 mutex_lock(&root->fs_info->trans_mutex);
 231         }
 232         mutex_unlock(&root->fs_info->trans_mutex);
 233         finish_wait(&commit->commit_wait, &wait);
 234         return 0;
 235 }
 236
 237 /*
 238  * rate limit against the drop_snapshot code.  This helps to slow down new
 239  * operations if the drop_snapshot code isn't able to keep up.
 240  */
 241 static void throttle_on_drops(struct btrfs_root *root)
 242 {
 243         struct btrfs_fs_info *info = root->fs_info;
 244         int harder_count = 0;
 245
 246 harder:
 247         if (atomic_read(&info->throttles)) {
 248                 DEFINE_WAIT(wait);
 249                 int thr;
 250                 thr = atomic_read(&info->throttle_gen);
 251
 252                 do {
 253                         prepare_to_wait(&info->transaction_throttle,
 254                                         &wait, TASK_UNINTERRUPTIBLE);
 255                         if (!atomic_read(&info->throttles)) {
 256                                 finish_wait(&info->transaction_throttle, &wait);
 257                                 break;
 258                         }
 259                         schedule();
 260                         finish_wait(&info->transaction_throttle, &wait);
 261                 } while (thr == atomic_read(&info->throttle_gen));
 262                 harder_count++;
 263
 264                 if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 &&
 265                     harder_count < 2)
 266                         goto harder;
 267
 268                 if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 &&
 269                     harder_count < 10)
 270                         goto harder;
 271
 272                 if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 &&
 273                     harder_count < 20)
 274                         goto harder;
 275         }
 276 }
 277
 278 void btrfs_throttle(struct btrfs_root *root)
 279 {
 280         mutex_lock(&root->fs_info->trans_mutex);
 281         if (!root->fs_info->open_ioctl_trans)
 282                 wait_current_trans(root);
 283         mutex_unlock(&root->fs_info->trans_mutex);
 284
 285         throttle_on_drops(root);
 286 }
 287
 288 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
 289                           struct btrfs_root *root, int throttle)
 290 {
 291         struct btrfs_transaction *cur_trans;
 292         struct btrfs_fs_info *info = root->fs_info;
 293         int count = 0;
 294
 295         while (count < 4) {
 296                 unsigned long cur = trans->delayed_ref_updates;
 297                 trans->delayed_ref_updates = 0;
 298                 if (cur &&
 299                     trans->transaction->delayed_refs.num_heads_ready > 64) {
 300                         trans->delayed_ref_updates = 0;
 301                         btrfs_run_delayed_refs(trans, root, cur);
 302                 } else {
 303                         break;
 304                 }
 305                 count++;
 306         }
 307
 308         mutex_lock(&info->trans_mutex);
 309         cur_trans = info->running_transaction;
 310         WARN_ON(cur_trans != trans->transaction);
 311         WARN_ON(cur_trans->num_writers < 1);
 312         cur_trans->num_writers--;
 313
 314         if (waitqueue_active(&cur_trans->writer_wait))
 315                 wake_up(&cur_trans->writer_wait);
 316         put_transaction(cur_trans);
 317         mutex_unlock(&info->trans_mutex);
 318         memset(trans, 0, sizeof(*trans));
 319         kmem_cache_free(btrfs_trans_handle_cachep, trans);
 320
 321         if (throttle)
 322                 throttle_on_drops(root);
 323
 324         return 0;
 325 }
 326
 327 int btrfs_end_transaction(struct btrfs_trans_handle *trans,
 328                           struct btrfs_root *root)
 329 {
 330         return __btrfs_end_transaction(trans, root, 0);
 331 }
 332
 333 int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
 334                                    struct btrfs_root *root)
 335 {
 336         return __btrfs_end_transaction(trans, root, 1);
 337 }
 338
 339 /*
 340  * when btree blocks are allocated, they have some corresponding bits set for
 341  * them in one of two extent_io trees.  This is used to make sure all of
 342  * those extents are on disk for transaction or log commit
 343  */
 344 int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
 345                                         struct extent_io_tree *dirty_pages)
 346 {
 347         int ret;
 348         int err = 0;
 349         int werr = 0;
 350         struct page *page;
 351         struct inode *btree_inode = root->fs_info->btree_inode;
 352         u64 start = 0;
 353         u64 end;
 354         unsigned long index;
 355
 356         while (1) {
 357                 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
 358                                             EXTENT_DIRTY);
 359                 if (ret)
 360                         break;
 361                 while (start <= end) {
 362                         cond_resched();
 363
 364                         index = start >> PAGE_CACHE_SHIFT;
 365                         start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
 366                         page = find_get_page(btree_inode->i_mapping, index);
 367                         if (!page)
 368                                 continue;
 369
 370                         btree_lock_page_hook(page);
 371                         if (!page->mapping) {
 372                                 unlock_page(page);
 373                                 page_cache_release(page);
 374                                 continue;
 375                         }
 376
 377                         if (PageWriteback(page)) {
 378                                 if (PageDirty(page))
 379                                         wait_on_page_writeback(page);
 380                                 else {
 381                                         unlock_page(page);
 382                                         page_cache_release(page);
 383                                         continue;
 384                                 }
 385                         }
 386                         err = write_one_page(page, 0);
 387                         if (err)
 388                                 werr = err;
 389                         page_cache_release(page);
 390                 }
 391         }
 392         while (1) {
 393                 ret = find_first_extent_bit(dirty_pages, 0, &start, &end,
 394                                             EXTENT_DIRTY);
 395                 if (ret)
 396                         break;
 397
 398                 clear_extent_dirty(dirty_pages, start, end, GFP_NOFS);
 399                 while (start <= end) {
 400                         index = start >> PAGE_CACHE_SHIFT;
 401                         start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
 402                         page = find_get_page(btree_inode->i_mapping, index);
 403                         if (!page)
 404                                 continue;
 405                         if (PageDirty(page)) {
 406                                 btree_lock_page_hook(page);
 407                                 wait_on_page_writeback(page);
 408                                 err = write_one_page(page, 0);
 409                                 if (err)
 410                                         werr = err;
 411                         }
 412                         wait_on_page_writeback(page);
 413                         page_cache_release(page);
 414                         cond_resched();
 415                 }
 416         }
 417         if (err)
 418                 werr = err;
 419         return werr;
 420 }
 421
 422 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
 423                                      struct btrfs_root *root)
 424 {
 425         if (!trans || !trans->transaction) {
 426                 struct inode *btree_inode;
 427                 btree_inode = root->fs_info->btree_inode;
 428                 return filemap_write_and_wait(btree_inode->i_mapping);
 429         }
 430         return btrfs_write_and_wait_marked_extents(root,
 431                                            &trans->transaction->dirty_pages);
 432 }
 433
 434 /*
 435  * this is used to update the root pointer in the tree of tree roots.
 436  *
 437  * But, in the case of the extent allocation tree, updating the root
 438  * pointer may allocate blocks which may change the root of the extent
 439  * allocation tree.
 440  *
 441  * So, this loops and repeats and makes sure the cowonly root didn't
 442  * change while the root pointer was being updated in the metadata.
 443  */
 444 static int update_cowonly_root(struct btrfs_trans_handle *trans,
 445                                struct btrfs_root *root)
 446 {
 447         int ret;
 448         u64 old_root_bytenr;
 449         struct btrfs_root *tree_root = root->fs_info->tree_root;
 450
 451         btrfs_write_dirty_block_groups(trans, root);
 452
 453         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 454         BUG_ON(ret);
 455
 456         while (1) {
 457                 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
 458                 if (old_root_bytenr == root->node->start)
 459                         break;
 460                 btrfs_set_root_bytenr(&root->root_item,
 461                                        root->node->start);
 462                 btrfs_set_root_level(&root->root_item,
 463                                      btrfs_header_level(root->node));
 464                 btrfs_set_root_generation(&root->root_item, trans->transid);
 465
 466                 ret = btrfs_update_root(trans, tree_root,
 467                                         &root->root_key,
 468                                         &root->root_item);
 469                 BUG_ON(ret);
 470                 btrfs_write_dirty_block_groups(trans, root);
 471
 472                 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 473                 BUG_ON(ret);
 474         }
 475         return 0;
 476 }
 477
 478 /*
 479  * update all the cowonly tree roots on disk
 480  */
 481 int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans,
 482                             struct btrfs_root *root)
 483 {
 484         struct btrfs_fs_info *fs_info = root->fs_info;
 485         struct list_head *next;
 486         struct extent_buffer *eb;
 487         int ret;
 488
 489         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 490         BUG_ON(ret);
 491
 492         eb = btrfs_lock_root_node(fs_info->tree_root);
 493         btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
 494         btrfs_tree_unlock(eb);
 495         free_extent_buffer(eb);
 496
 497         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 498         BUG_ON(ret);
 499
 500         while (!list_empty(&fs_info->dirty_cowonly_roots)) {
 501                 next = fs_info->dirty_cowonly_roots.next;
 502                 list_del_init(next);
 503                 root = list_entry(next, struct btrfs_root, dirty_list);
 504
 505                 update_cowonly_root(trans, root);
 506
 507                 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 508                 BUG_ON(ret);
 509         }
 510         return 0;
 511 }
 512
 513 /*
 514  * dead roots are old snapshots that need to be deleted.  This allocates
 515  * a dirty root struct and adds it into the list of dead roots that need to
 516  * be deleted
 517  */
 518 int btrfs_add_dead_root(struct btrfs_root *root, struct btrfs_root *latest)
 519 {
 520         struct btrfs_dirty_root *dirty;
 521
 522         dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
 523         if (!dirty)
 524                 return -ENOMEM;
 525         dirty->root = root;
 526         dirty->latest_root = latest;
 527
 528         mutex_lock(&root->fs_info->trans_mutex);
 529         list_add(&dirty->list, &latest->fs_info->dead_roots);
 530         mutex_unlock(&root->fs_info->trans_mutex);
 531         return 0;
 532 }
 533
 534 /*
 535  * at transaction commit time we need to schedule the old roots for
 536  * deletion via btrfs_drop_snapshot.  This runs through all the
 537  * reference counted roots that were modified in the current
 538  * transaction and puts them into the drop list
 539  */
 540 static noinline int add_dirty_roots(struct btrfs_trans_handle *trans,
 541                                     struct radix_tree_root *radix,
 542                                     struct list_head *list)
 543 {
 544         struct btrfs_dirty_root *dirty;
 545         struct btrfs_root *gang[8];
 546         struct btrfs_root *root;
 547         int i;
 548         int ret;
 549         int err = 0;
 550         u32 refs;
 551
 552         while (1) {
 553                 ret = radix_tree_gang_lookup_tag(radix, (void **)gang, 0,
 554                                                  ARRAY_SIZE(gang),
 555                                                  BTRFS_ROOT_TRANS_TAG);
 556                 if (ret == 0)
 557                         break;
 558                 for (i = 0; i < ret; i++) {
 559                         root = gang[i];
 560                         radix_tree_tag_clear(radix,
 561                                      (unsigned long)root->root_key.objectid,
 562                                      BTRFS_ROOT_TRANS_TAG);
 563
 564                         BUG_ON(!root->ref_tree);
 565                         dirty = root->dirty_root;
 566
 567                         btrfs_free_log(trans, root);
 568                         btrfs_free_reloc_root(trans, root);
 569
 570                         if (root->commit_root == root->node) {
 571                                 WARN_ON(root->node->start !=
 572                                         btrfs_root_bytenr(&root->root_item));
 573
 574                                 free_extent_buffer(root->commit_root);
 575                                 root->commit_root = NULL;
 576                                 root->dirty_root = NULL;
 577
 578                                 spin_lock(&root->list_lock);
 579                                 list_del_init(&dirty->root->dead_list);
 580                                 spin_unlock(&root->list_lock);
 581
 582                                 kfree(dirty->root);
 583                                 kfree(dirty);
 584
 585                                 /* make sure to update the root on disk
 586                                  * so we get any updates to the block used
 587                                  * counts
 588                                  */
 589                                 err = btrfs_update_root(trans,
 590                                                 root->fs_info->tree_root,
 591                                                 &root->root_key,
 592                                                 &root->root_item);
 593                                 continue;
 594                         }
 595
 596                         memset(&root->root_item.drop_progress, 0,
 597                                sizeof(struct btrfs_disk_key));
 598                         root->root_item.drop_level = 0;
 599                         root->commit_root = NULL;
 600                         root->dirty_root = NULL;
 601                         root->root_key.offset = root->fs_info->generation;
 602                         btrfs_set_root_bytenr(&root->root_item,
 603                                               root->node->start);
 604                         btrfs_set_root_level(&root->root_item,
 605                                              btrfs_header_level(root->node));
 606                         btrfs_set_root_generation(&root->root_item,
 607                                                   root->root_key.offset);
 608
 609                         err = btrfs_insert_root(trans, root->fs_info->tree_root,
 610                                                 &root->root_key,
 611                                                 &root->root_item);
 612                         if (err)
 613                                 break;
 614
 615                         refs = btrfs_root_refs(&dirty->root->root_item);
 616                         btrfs_set_root_refs(&dirty->root->root_item, refs - 1);
 617                         err = btrfs_update_root(trans, root->fs_info->tree_root,
 618                                                 &dirty->root->root_key,
 619                                                 &dirty->root->root_item);
 620
 621                         BUG_ON(err);
 622                         if (refs == 1) {
 623                                 list_add(&dirty->list, list);
 624                         } else {
 625                                 WARN_ON(1);
 626                                 free_extent_buffer(dirty->root->node);
 627                                 kfree(dirty->root);
 628                                 kfree(dirty);
 629                         }
 630                 }
 631         }
 632         return err;
 633 }
 634
 635 /*
 636  * defrag a given btree.  If cacheonly == 1, this won't read from the disk,
 637  * otherwise every leaf in the btree is read and defragged.
 638  */
 639 int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
 640 {
 641         struct btrfs_fs_info *info = root->fs_info;
 642         int ret;
 643         struct btrfs_trans_handle *trans;
 644         unsigned long nr;
 645
 646         smp_mb();
 647         if (root->defrag_running)
 648                 return 0;
 649         trans = btrfs_start_transaction(root, 1);
 650         while (1) {
 651                 root->defrag_running = 1;
 652                 ret = btrfs_defrag_leaves(trans, root, cacheonly);
 653                 nr = trans->blocks_used;
 654                 btrfs_end_transaction(trans, root);
 655                 btrfs_btree_balance_dirty(info->tree_root, nr);
 656                 cond_resched();
 657
 658                 trans = btrfs_start_transaction(root, 1);
 659                 if (root->fs_info->closing || ret != -EAGAIN)
 660                         break;
 661         }
 662         root->defrag_running = 0;
 663         smp_mb();
 664         btrfs_end_transaction(trans, root);
 665         return 0;
 666 }
 667
 668 /*
 669  * Given a list of roots that need to be deleted, call btrfs_drop_snapshot on
 670  * all of them
 671  */
 672 static noinline int drop_dirty_roots(struct btrfs_root *tree_root,
 673                                      struct list_head *list)
 674 {
 675         struct btrfs_dirty_root *dirty;
 676         struct btrfs_trans_handle *trans;
 677         unsigned long nr;
 678         u64 num_bytes;
 679         u64 bytes_used;
 680         u64 max_useless;
 681         int ret = 0;
 682         int err;
 683
 684         while (!list_empty(list)) {
 685                 struct btrfs_root *root;
 686
 687                 dirty = list_entry(list->prev, struct btrfs_dirty_root, list);
 688                 list_del_init(&dirty->list);
 689
 690                 num_bytes = btrfs_root_used(&dirty->root->root_item);
 691                 root = dirty->latest_root;
 692                 atomic_inc(&root->fs_info->throttles);
 693
 694                 while (1) {
 695                         trans = btrfs_start_transaction(tree_root, 1);
 696                         mutex_lock(&root->fs_info->drop_mutex);
 697                         ret = btrfs_drop_snapshot(trans, dirty->root);
 698                         if (ret != -EAGAIN)
 699                                 break;
 700                         mutex_unlock(&root->fs_info->drop_mutex);
 701
 702                         err = btrfs_update_root(trans,
 703                                         tree_root,
 704                                         &dirty->root->root_key,
 705                                         &dirty->root->root_item);
 706                         if (err)
 707                                 ret = err;
 708                         nr = trans->blocks_used;
 709                         ret = btrfs_end_transaction(trans, tree_root);
 710                         BUG_ON(ret);
 711
 712                         btrfs_btree_balance_dirty(tree_root, nr);
 713                         cond_resched();
 714                 }
 715                 BUG_ON(ret);
 716                 atomic_dec(&root->fs_info->throttles);
 717                 wake_up(&root->fs_info->transaction_throttle);
 718
 719                 num_bytes -= btrfs_root_used(&dirty->root->root_item);
 720                 bytes_used = btrfs_root_used(&root->root_item);
 721                 if (num_bytes) {
 722                         mutex_lock(&root->fs_info->trans_mutex);
 723                         btrfs_record_root_in_trans(root);
 724                         mutex_unlock(&root->fs_info->trans_mutex);
 725                         btrfs_set_root_used(&root->root_item,
 726                                             bytes_used - num_bytes);
 727                 }
 728
 729                 ret = btrfs_del_root(trans, tree_root, &dirty->root->root_key);
 730                 if (ret) {
 731                         BUG();
 732                         break;
 733                 }
 734                 mutex_unlock(&root->fs_info->drop_mutex);
 735
 736                 spin_lock(&root->list_lock);
 737                 list_del_init(&dirty->root->dead_list);
 738                 if (!list_empty(&root->dead_list)) {
 739                         struct btrfs_root *oldest;
 740                         oldest = list_entry(root->dead_list.prev,
 741                                             struct btrfs_root, dead_list);
 742                         max_useless = oldest->root_key.offset - 1;
 743                 } else {
 744                         max_useless = root->root_key.offset - 1;
 745                 }
 746                 spin_unlock(&root->list_lock);
 747
 748                 nr = trans->blocks_used;
 749                 ret = btrfs_end_transaction(trans, tree_root);
 750                 BUG_ON(ret);
 751
 752                 ret = btrfs_remove_leaf_refs(root, max_useless, 0);
 753                 BUG_ON(ret);
 754
 755                 free_extent_buffer(dirty->root->node);
 756                 kfree(dirty->root);
 757                 kfree(dirty);
 758
 759                 btrfs_btree_balance_dirty(tree_root, nr);
 760                 cond_resched();
 761         }
 762         return ret;
 763 }
 764
 765 /*
 766  * new snapshots need to be created at a very specific time in the
 767  * transaction commit.  This does the actual creation
 768  */
 769 static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
 770                                    struct btrfs_fs_info *fs_info,
 771                                    struct btrfs_pending_snapshot *pending)
 772 {
 773         struct btrfs_key key;
 774         struct btrfs_root_item *new_root_item;
 775         struct btrfs_root *tree_root = fs_info->tree_root;
 776         struct btrfs_root *root = pending->root;
 777         struct extent_buffer *tmp;
 778         struct extent_buffer *old;
 779         int ret;
 780         u64 objectid;
 781
 782         new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
 783         if (!new_root_item) {
 784                 ret = -ENOMEM;
 785                 goto fail;
 786         }
 787         ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid);
 788         if (ret)
 789                 goto fail;
 790
 791         btrfs_record_root_in_trans(root);
 792         btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
 793         memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
 794
 795         key.objectid = objectid;
 796         key.offset = trans->transid;
 797         btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
 798
 799         old = btrfs_lock_root_node(root);
 800         btrfs_cow_block(trans, root, old, NULL, 0, &old);
 801
 802         btrfs_copy_root(trans, root, old, &tmp, objectid);
 803         btrfs_tree_unlock(old);
 804         free_extent_buffer(old);
 805
 806         btrfs_set_root_bytenr(new_root_item, tmp->start);
 807         btrfs_set_root_level(new_root_item, btrfs_header_level(tmp));
 808         btrfs_set_root_generation(new_root_item, trans->transid);
 809         ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
 810                                 new_root_item);
 811         btrfs_tree_unlock(tmp);
 812         free_extent_buffer(tmp);
 813         if (ret)
 814                 goto fail;
 815
 816         key.offset = (u64)-1;
 817         memcpy(&pending->root_key, &key, sizeof(key));
 818 fail:
 819         kfree(new_root_item);
 820         return ret;
 821 }
 822
 823 static noinline int finish_pending_snapshot(struct btrfs_fs_info *fs_info,
 824                                    struct btrfs_pending_snapshot *pending)
 825 {
 826         int ret;
 827         int namelen;
 828         u64 index = 0;
 829         struct btrfs_trans_handle *trans;
 830         struct inode *parent_inode;
 831         struct inode *inode;
 832         struct btrfs_root *parent_root;
 833
 834         parent_inode = pending->dentry->d_parent->d_inode;
 835         parent_root = BTRFS_I(parent_inode)->root;
 836         trans = btrfs_join_transaction(parent_root, 1);
 837
 838         /*
 839          * insert the directory item
 840          */
 841         namelen = strlen(pending->name);
 842         ret = btrfs_set_inode_index(parent_inode, &index);
 843         ret = btrfs_insert_dir_item(trans, parent_root,
 844                             pending->name, namelen,
 845                             parent_inode->i_ino,
 846                             &pending->root_key, BTRFS_FT_DIR, index);
 847
 848         if (ret)
 849                 goto fail;
 850
 851         btrfs_i_size_write(parent_inode, parent_inode->i_size + namelen * 2);
 852         ret = btrfs_update_inode(trans, parent_root, parent_inode);
 853         BUG_ON(ret);
 854
 855         /* add the backref first */
 856         ret = btrfs_add_root_ref(trans, parent_root->fs_info->tree_root,
 857                                  pending->root_key.objectid,
 858                                  BTRFS_ROOT_BACKREF_KEY,
 859                                  parent_root->root_key.objectid,
 860                                  parent_inode->i_ino, index, pending->name,
 861                                  namelen);
 862
 863         BUG_ON(ret);
 864
 865         /* now add the forward ref */
 866         ret = btrfs_add_root_ref(trans, parent_root->fs_info->tree_root,
 867                                  parent_root->root_key.objectid,
 868                                  BTRFS_ROOT_REF_KEY,
 869                                  pending->root_key.objectid,
 870                                  parent_inode->i_ino, index, pending->name,
 871                                  namelen);
 872
 873         inode = btrfs_lookup_dentry(parent_inode, pending->dentry);
 874         d_instantiate(pending->dentry, inode);
 875 fail:
 876         btrfs_end_transaction(trans, fs_info->fs_root);
 877         return ret;
 878 }
 879
 880 /*
 881  * create all the snapshots we've scheduled for creation
 882  */
 883 static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
 884                                              struct btrfs_fs_info *fs_info)
 885 {
 886         struct btrfs_pending_snapshot *pending;
 887         struct list_head *head = &trans->transaction->pending_snapshots;
 888         int ret;
 889
 890         list_for_each_entry(pending, head, list) {
 891                 ret = create_pending_snapshot(trans, fs_info, pending);
 892                 BUG_ON(ret);
 893         }
 894         return 0;
 895 }
 896
 897 static noinline int finish_pending_snapshots(struct btrfs_trans_handle *trans,
 898                                              struct btrfs_fs_info *fs_info)
 899 {
 900         struct btrfs_pending_snapshot *pending;
 901         struct list_head *head = &trans->transaction->pending_snapshots;
 902         int ret;
 903
 904         while (!list_empty(head)) {
 905                 pending = list_entry(head->next,
 906                                      struct btrfs_pending_snapshot, list);
 907                 ret = finish_pending_snapshot(fs_info, pending);
 908                 BUG_ON(ret);
 909                 list_del(&pending->list);
 910                 kfree(pending->name);
 911                 kfree(pending);
 912         }
 913         return 0;
 914 }
 915
 916 int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
 917                              struct btrfs_root *root)
 918 {
 919         unsigned long joined = 0;
 920         unsigned long timeout = 1;
 921         struct btrfs_transaction *cur_trans;
 922         struct btrfs_transaction *prev_trans = NULL;
 923         struct btrfs_root *chunk_root = root->fs_info->chunk_root;
 924         struct list_head dirty_fs_roots;
 925         struct extent_io_tree *pinned_copy;
 926         DEFINE_WAIT(wait);
 927         int ret;
 928
 929         /* make a pass through all the delayed refs we have so far
 930          * any runnings procs may add more while we are here
 931          */
 932         ret = btrfs_run_delayed_refs(trans, root, 0);
 933         BUG_ON(ret);
 934
 935         /*
 936          * set the flushing flag so procs in this transaction have to
 937          * start sending their work down.
 938          */
 939         trans->transaction->delayed_refs.flushing = 1;
 940
 941         ret = btrfs_run_delayed_refs(trans, root, 0);
 942         BUG_ON(ret);
 943
 944         INIT_LIST_HEAD(&dirty_fs_roots);
 945         mutex_lock(&root->fs_info->trans_mutex);
 946         if (trans->transaction->in_commit) {
 947                 cur_trans = trans->transaction;
 948                 trans->transaction->use_count++;
 949                 mutex_unlock(&root->fs_info->trans_mutex);
 950                 btrfs_end_transaction(trans, root);
 951
 952                 ret = wait_for_commit(root, cur_trans);
 953                 BUG_ON(ret);
 954
 955                 mutex_lock(&root->fs_info->trans_mutex);
 956                 put_transaction(cur_trans);
 957                 mutex_unlock(&root->fs_info->trans_mutex);
 958
 959                 return 0;
 960         }
 961
 962         pinned_copy = kmalloc(sizeof(*pinned_copy), GFP_NOFS);
 963         if (!pinned_copy)
 964                 return -ENOMEM;
 965
 966         extent_io_tree_init(pinned_copy,
 967                              root->fs_info->btree_inode->i_mapping, GFP_NOFS);
 968
 969         trans->transaction->in_commit = 1;
 970         trans->transaction->blocked = 1;
 971         cur_trans = trans->transaction;
 972         if (cur_trans->list.prev != &root->fs_info->trans_list) {
 973                 prev_trans = list_entry(cur_trans->list.prev,
 974                                         struct btrfs_transaction, list);
 975                 if (!prev_trans->commit_done) {
 976                         prev_trans->use_count++;
 977                         mutex_unlock(&root->fs_info->trans_mutex);
 978
 979                         wait_for_commit(root, prev_trans);
 980
 981                         mutex_lock(&root->fs_info->trans_mutex);
 982                         put_transaction(prev_trans);
 983                 }
 984         }
 985
 986         do {
 987                 int snap_pending = 0;
 988                 joined = cur_trans->num_joined;
 989                 if (!list_empty(&trans->transaction->pending_snapshots))
 990                         snap_pending = 1;
 991
 992                 WARN_ON(cur_trans != trans->transaction);
 993                 prepare_to_wait(&cur_trans->writer_wait, &wait,
 994                                 TASK_UNINTERRUPTIBLE);
 995
 996                 if (cur_trans->num_writers > 1)
 997                         timeout = MAX_SCHEDULE_TIMEOUT;
 998                 else
 999                         timeout = 1;
1000
1001                 mutex_unlock(&root->fs_info->trans_mutex);
1002
1003                 if (snap_pending) {
1004                         ret = btrfs_wait_ordered_extents(root, 1);
1005                         BUG_ON(ret);
1006                 }
1007
1008                 schedule_timeout(timeout);
1009
1010                 mutex_lock(&root->fs_info->trans_mutex);
1011                 finish_wait(&cur_trans->writer_wait, &wait);
1012         } while (cur_trans->num_writers > 1 ||
1013                  (cur_trans->num_joined != joined));
1014
1015         ret = create_pending_snapshots(trans, root->fs_info);
1016         BUG_ON(ret);
1017
1018         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1019         BUG_ON(ret);
1020
1021         WARN_ON(cur_trans != trans->transaction);
1022
1023         /* btrfs_commit_tree_roots is responsible for getting the
1024          * various roots consistent with each other.  Every pointer
1025          * in the tree of tree roots has to point to the most up to date
1026          * root for every subvolume and other tree.  So, we have to keep
1027          * the tree logging code from jumping in and changing any
1028          * of the trees.
1029          *
1030          * At this point in the commit, there can't be any tree-log
1031          * writers, but a little lower down we drop the trans mutex
1032          * and let new people in.  By holding the tree_log_mutex
1033          * from now until after the super is written, we avoid races
1034          * with the tree-log code.
1035          */
1036         mutex_lock(&root->fs_info->tree_log_mutex);
1037         /*
1038          * keep tree reloc code from adding new reloc trees
1039          */
1040         mutex_lock(&root->fs_info->tree_reloc_mutex);
1041
1042
1043         ret = add_dirty_roots(trans, &root->fs_info->fs_roots_radix,
1044                               &dirty_fs_roots);
1045         BUG_ON(ret);
1046
1047         /* add_dirty_roots gets rid of all the tree log roots, it is now
1048          * safe to free the root of tree log roots
1049          */
1050         btrfs_free_log_root_tree(trans, root->fs_info);
1051
1052         ret = btrfs_commit_tree_roots(trans, root);
1053         BUG_ON(ret);
1054
1055         cur_trans = root->fs_info->running_transaction;
1056         spin_lock(&root->fs_info->new_trans_lock);
1057         root->fs_info->running_transaction = NULL;
1058         spin_unlock(&root->fs_info->new_trans_lock);
1059         btrfs_set_super_generation(&root->fs_info->super_copy,
1060                                    cur_trans->transid);
1061         btrfs_set_super_root(&root->fs_info->super_copy,
1062                              root->fs_info->tree_root->node->start);
1063         btrfs_set_super_root_level(&root->fs_info->super_copy,
1064                            btrfs_header_level(root->fs_info->tree_root->node));
1065
1066         btrfs_set_super_chunk_root(&root->fs_info->super_copy,
1067                                    chunk_root->node->start);
1068         btrfs_set_super_chunk_root_level(&root->fs_info->super_copy,
1069                                          btrfs_header_level(chunk_root->node));
1070         btrfs_set_super_chunk_root_generation(&root->fs_info->super_copy,
1071                                 btrfs_header_generation(chunk_root->node));
1072
1073         if (!root->fs_info->log_root_recovering) {
1074                 btrfs_set_super_log_root(&root->fs_info->super_copy, 0);
1075                 btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0);
1076         }
1077
1078         memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
1079                sizeof(root->fs_info->super_copy));
1080
1081         btrfs_copy_pinned(root, pinned_copy);
1082
1083         trans->transaction->blocked = 0;
1084         wake_up(&root->fs_info->transaction_throttle);
1085         wake_up(&root->fs_info->transaction_wait);
1086
1087         mutex_unlock(&root->fs_info->trans_mutex);
1088         ret = btrfs_write_and_wait_transaction(trans, root);
1089         BUG_ON(ret);
1090         write_ctree_super(trans, root, 0);
1091
1092         /*
1093          * the super is written, we can safely allow the tree-loggers
1094          * to go about their business
1095          */
1096         mutex_unlock(&root->fs_info->tree_log_mutex);
1097
1098         btrfs_finish_extent_commit(trans, root, pinned_copy);
1099         kfree(pinned_copy);
1100
1101         btrfs_drop_dead_reloc_roots(root);
1102         mutex_unlock(&root->fs_info->tree_reloc_mutex);
1103
1104         /* do the directory inserts of any pending snapshot creations */
1105         finish_pending_snapshots(trans, root->fs_info);
1106
1107         mutex_lock(&root->fs_info->trans_mutex);
1108
1109         cur_trans->commit_done = 1;
1110         root->fs_info->last_trans_committed = cur_trans->transid;
1111         wake_up(&cur_trans->commit_wait);
1112
1113         put_transaction(cur_trans);
1114         put_transaction(cur_trans);
1115
1116         list_splice_init(&dirty_fs_roots, &root->fs_info->dead_roots);
1117         if (root->fs_info->closing)
1118                 list_splice_init(&root->fs_info->dead_roots, &dirty_fs_roots);
1119
1120         mutex_unlock(&root->fs_info->trans_mutex);
1121
1122         kmem_cache_free(btrfs_trans_handle_cachep, trans);
1123
1124         if (root->fs_info->closing)
1125                 drop_dirty_roots(root->fs_info->tree_root, &dirty_fs_roots);
1126         return ret;
1127 }
1128
1129 /*
1130  * interface function to delete all the snapshots we have scheduled for deletion
1131  */
1132 int btrfs_clean_old_snapshots(struct btrfs_root *root)
1133 {
1134         struct list_head dirty_roots;
1135         INIT_LIST_HEAD(&dirty_roots);
1136 again:
1137         mutex_lock(&root->fs_info->trans_mutex);
1138         list_splice_init(&root->fs_info->dead_roots, &dirty_roots);
1139         mutex_unlock(&root->fs_info->trans_mutex);
1140
1141         if (!list_empty(&dirty_roots)) {
1142                 drop_dirty_roots(root, &dirty_roots);
1143                 goto again;
1144         }
1145         return 0;
1146 }