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 "ctree.h"
  24 #include "disk-io.h"
  25 #include "transaction.h"
  26 #include "locking.h"
  27
  28 static int total_trans = 0;
  29 extern struct kmem_cache *btrfs_trans_handle_cachep;
  30 extern struct kmem_cache *btrfs_transaction_cachep;
  31
  32 static struct workqueue_struct *trans_wq;
  33
  34 #define BTRFS_ROOT_TRANS_TAG 0
  35 #define BTRFS_ROOT_DEFRAG_TAG 1
  36
  37 static noinline void put_transaction(struct btrfs_transaction *transaction)
  38 {
  39         WARN_ON(transaction->use_count == 0);
  40         transaction->use_count--;
  41         if (transaction->use_count == 0) {
  42                 WARN_ON(total_trans == 0);
  43                 total_trans--;
  44                 list_del_init(&transaction->list);
  45                 memset(transaction, 0, sizeof(*transaction));
  46                 kmem_cache_free(btrfs_transaction_cachep, transaction);
  47         }
  48 }
  49
  50 static noinline int join_transaction(struct btrfs_root *root)
  51 {
  52         struct btrfs_transaction *cur_trans;
  53         cur_trans = root->fs_info->running_transaction;
  54         if (!cur_trans) {
  55                 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep,
  56                                              GFP_NOFS);
  57                 total_trans++;
  58                 BUG_ON(!cur_trans);
  59                 root->fs_info->generation++;
  60                 root->fs_info->last_alloc = 0;
  61                 root->fs_info->last_data_alloc = 0;
  62                 cur_trans->num_writers = 1;
  63                 cur_trans->num_joined = 0;
  64                 cur_trans->transid = root->fs_info->generation;
  65                 init_waitqueue_head(&cur_trans->writer_wait);
  66                 init_waitqueue_head(&cur_trans->commit_wait);
  67                 cur_trans->in_commit = 0;
  68                 cur_trans->use_count = 1;
  69                 cur_trans->commit_done = 0;
  70                 cur_trans->start_time = get_seconds();
  71                 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
  72                 list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
  73                 btrfs_ordered_inode_tree_init(&cur_trans->ordered_inode_tree);
  74                 extent_io_tree_init(&cur_trans->dirty_pages,
  75                                      root->fs_info->btree_inode->i_mapping,
  76                                      GFP_NOFS);
  77                 spin_lock(&root->fs_info->new_trans_lock);
  78                 root->fs_info->running_transaction = cur_trans;
  79                 spin_unlock(&root->fs_info->new_trans_lock);
  80         } else {
  81                 cur_trans->num_writers++;
  82                 cur_trans->num_joined++;
  83         }
  84
  85         return 0;
  86 }
  87
  88 static noinline int record_root_in_trans(struct btrfs_root *root)
  89 {
  90         u64 running_trans_id = root->fs_info->running_transaction->transid;
  91         if (root->ref_cows && root->last_trans < running_trans_id) {
  92                 WARN_ON(root == root->fs_info->extent_root);
  93                 if (root->root_item.refs != 0) {
  94                         radix_tree_tag_set(&root->fs_info->fs_roots_radix,
  95                                    (unsigned long)root->root_key.objectid,
  96                                    BTRFS_ROOT_TRANS_TAG);
  97                         radix_tree_tag_set(&root->fs_info->fs_roots_radix,
  98                                    (unsigned long)root->root_key.objectid,
  99                                    BTRFS_ROOT_DEFRAG_TAG);
 100                         root->commit_root = btrfs_root_node(root);
 101                 } else {
 102                         WARN_ON(1);
 103                 }
 104                 root->last_trans = running_trans_id;
 105         }
 106         return 0;
 107 }
 108
 109 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
 110                                                    int num_blocks)
 111 {
 112         struct btrfs_trans_handle *h =
 113                 kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
 114         int ret;
 115
 116         mutex_lock(&root->fs_info->trans_mutex);
 117         ret = join_transaction(root);
 118         BUG_ON(ret);
 119
 120         record_root_in_trans(root);
 121         h->transid = root->fs_info->running_transaction->transid;
 122         h->transaction = root->fs_info->running_transaction;
 123         h->blocks_reserved = num_blocks;
 124         h->blocks_used = 0;
 125         h->block_group = NULL;
 126         h->alloc_exclude_nr = 0;
 127         h->alloc_exclude_start = 0;
 128         root->fs_info->running_transaction->use_count++;
 129         mutex_unlock(&root->fs_info->trans_mutex);
 130         return h;
 131 }
 132
 133 static noinline int wait_for_commit(struct btrfs_root *root,
 134                                     struct btrfs_transaction *commit)
 135 {
 136         DEFINE_WAIT(wait);
 137         mutex_lock(&root->fs_info->trans_mutex);
 138         while(!commit->commit_done) {
 139                 prepare_to_wait(&commit->commit_wait, &wait,
 140                                 TASK_UNINTERRUPTIBLE);
 141                 if (commit->commit_done)
 142                         break;
 143                 mutex_unlock(&root->fs_info->trans_mutex);
 144                 schedule();
 145                 mutex_lock(&root->fs_info->trans_mutex);
 146         }
 147         mutex_unlock(&root->fs_info->trans_mutex);
 148         finish_wait(&commit->commit_wait, &wait);
 149         return 0;
 150 }
 151
 152 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
 153                           struct btrfs_root *root, int throttle)
 154 {
 155         struct btrfs_transaction *cur_trans;
 156
 157         mutex_lock(&root->fs_info->trans_mutex);
 158         cur_trans = root->fs_info->running_transaction;
 159         WARN_ON(cur_trans != trans->transaction);
 160         WARN_ON(cur_trans->num_writers < 1);
 161         cur_trans->num_writers--;
 162
 163         if (waitqueue_active(&cur_trans->writer_wait))
 164                 wake_up(&cur_trans->writer_wait);
 165
 166         if (cur_trans->in_commit && throttle) {
 167                 int ret;
 168                 mutex_unlock(&root->fs_info->trans_mutex);
 169                 ret = wait_for_commit(root, cur_trans);
 170                 BUG_ON(ret);
 171                 mutex_lock(&root->fs_info->trans_mutex);
 172         }
 173
 174         put_transaction(cur_trans);
 175         mutex_unlock(&root->fs_info->trans_mutex);
 176         memset(trans, 0, sizeof(*trans));
 177         kmem_cache_free(btrfs_trans_handle_cachep, trans);
 178         return 0;
 179 }
 180
 181 int btrfs_end_transaction(struct btrfs_trans_handle *trans,
 182                           struct btrfs_root *root)
 183 {
 184         return __btrfs_end_transaction(trans, root, 0);
 185 }
 186
 187 int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
 188                                    struct btrfs_root *root)
 189 {
 190         return __btrfs_end_transaction(trans, root, 1);
 191 }
 192
 193
 194 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
 195                                      struct btrfs_root *root)
 196 {
 197         int ret;
 198         int err;
 199         int werr = 0;
 200         struct extent_io_tree *dirty_pages;
 201         struct page *page;
 202         struct inode *btree_inode = root->fs_info->btree_inode;
 203         u64 start;
 204         u64 end;
 205         unsigned long index;
 206
 207         if (!trans || !trans->transaction) {
 208                 return filemap_write_and_wait(btree_inode->i_mapping);
 209         }
 210         dirty_pages = &trans->transaction->dirty_pages;
 211         while(1) {
 212                 ret = find_first_extent_bit(dirty_pages, 0, &start, &end,
 213                                             EXTENT_DIRTY);
 214                 if (ret)
 215                         break;
 216                 clear_extent_dirty(dirty_pages, start, end, GFP_NOFS);
 217                 while(start <= end) {
 218                         index = start >> PAGE_CACHE_SHIFT;
 219                         start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
 220                         page = find_lock_page(btree_inode->i_mapping, index);
 221                         if (!page)
 222                                 continue;
 223                         if (PageWriteback(page)) {
 224                                 if (PageDirty(page))
 225                                         wait_on_page_writeback(page);
 226                                 else {
 227                                         unlock_page(page);
 228                                         page_cache_release(page);
 229                                         continue;
 230                                 }
 231                         }
 232                         err = write_one_page(page, 0);
 233                         if (err)
 234                                 werr = err;
 235                         page_cache_release(page);
 236                 }
 237         }
 238         err = filemap_fdatawait(btree_inode->i_mapping);
 239         if (err)
 240                 werr = err;
 241         return werr;
 242 }
 243
 244 static int update_cowonly_root(struct btrfs_trans_handle *trans,
 245                                struct btrfs_root *root)
 246 {
 247         int ret;
 248         u64 old_root_bytenr;
 249         struct btrfs_root *tree_root = root->fs_info->tree_root;
 250
 251         btrfs_write_dirty_block_groups(trans, root);
 252         while(1) {
 253                 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
 254                 if (old_root_bytenr == root->node->start)
 255                         break;
 256                 btrfs_set_root_bytenr(&root->root_item,
 257                                        root->node->start);
 258                 btrfs_set_root_level(&root->root_item,
 259                                      btrfs_header_level(root->node));
 260                 ret = btrfs_update_root(trans, tree_root,
 261                                         &root->root_key,
 262                                         &root->root_item);
 263                 BUG_ON(ret);
 264                 btrfs_write_dirty_block_groups(trans, root);
 265         }
 266         return 0;
 267 }
 268
 269 int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans,
 270                             struct btrfs_root *root)
 271 {
 272         struct btrfs_fs_info *fs_info = root->fs_info;
 273         struct list_head *next;
 274
 275         while(!list_empty(&fs_info->dirty_cowonly_roots)) {
 276                 next = fs_info->dirty_cowonly_roots.next;
 277                 list_del_init(next);
 278                 root = list_entry(next, struct btrfs_root, dirty_list);
 279                 update_cowonly_root(trans, root);
 280         }
 281         return 0;
 282 }
 283
 284 struct dirty_root {
 285         struct list_head list;
 286         struct btrfs_root *root;
 287         struct btrfs_root *latest_root;
 288 };
 289
 290 int btrfs_add_dead_root(struct btrfs_root *root,
 291                         struct btrfs_root *latest,
 292                         struct list_head *dead_list)
 293 {
 294         struct dirty_root *dirty;
 295
 296         dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
 297         if (!dirty)
 298                 return -ENOMEM;
 299         dirty->root = root;
 300         dirty->latest_root = latest;
 301         list_add(&dirty->list, dead_list);
 302         return 0;
 303 }
 304
 305 static noinline int add_dirty_roots(struct btrfs_trans_handle *trans,
 306                                     struct radix_tree_root *radix,
 307                                     struct list_head *list)
 308 {
 309         struct dirty_root *dirty;
 310         struct btrfs_root *gang[8];
 311         struct btrfs_root *root;
 312         int i;
 313         int ret;
 314         int err = 0;
 315         u32 refs;
 316
 317         while(1) {
 318                 ret = radix_tree_gang_lookup_tag(radix, (void **)gang, 0,
 319                                                  ARRAY_SIZE(gang),
 320                                                  BTRFS_ROOT_TRANS_TAG);
 321                 if (ret == 0)
 322                         break;
 323                 for (i = 0; i < ret; i++) {
 324                         root = gang[i];
 325                         radix_tree_tag_clear(radix,
 326                                      (unsigned long)root->root_key.objectid,
 327                                      BTRFS_ROOT_TRANS_TAG);
 328                         if (root->commit_root == root->node) {
 329                                 WARN_ON(root->node->start !=
 330                                         btrfs_root_bytenr(&root->root_item));
 331                                 free_extent_buffer(root->commit_root);
 332                                 root->commit_root = NULL;
 333
 334                                 /* make sure to update the root on disk
 335                                  * so we get any updates to the block used
 336                                  * counts
 337                                  */
 338                                 err = btrfs_update_root(trans,
 339                                                 root->fs_info->tree_root,
 340                                                 &root->root_key,
 341                                                 &root->root_item);
 342                                 continue;
 343                         }
 344                         dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
 345                         BUG_ON(!dirty);
 346                         dirty->root = kmalloc(sizeof(*dirty->root), GFP_NOFS);
 347                         BUG_ON(!dirty->root);
 348
 349                         memset(&root->root_item.drop_progress, 0,
 350                                sizeof(struct btrfs_disk_key));
 351                         root->root_item.drop_level = 0;
 352
 353                         memcpy(dirty->root, root, sizeof(*root));
 354                         dirty->root->node = root->commit_root;
 355                         dirty->latest_root = root;
 356                         root->commit_root = NULL;
 357
 358                         root->root_key.offset = root->fs_info->generation;
 359                         btrfs_set_root_bytenr(&root->root_item,
 360                                               root->node->start);
 361                         btrfs_set_root_level(&root->root_item,
 362                                              btrfs_header_level(root->node));
 363                         err = btrfs_insert_root(trans, root->fs_info->tree_root,
 364                                                 &root->root_key,
 365                                                 &root->root_item);
 366                         if (err)
 367                                 break;
 368
 369                         refs = btrfs_root_refs(&dirty->root->root_item);
 370                         btrfs_set_root_refs(&dirty->root->root_item, refs - 1);
 371                         err = btrfs_update_root(trans, root->fs_info->tree_root,
 372                                                 &dirty->root->root_key,
 373                                                 &dirty->root->root_item);
 374
 375                         BUG_ON(err);
 376                         if (refs == 1) {
 377                                 list_add(&dirty->list, list);
 378                         } else {
 379                                 WARN_ON(1);
 380                                 kfree(dirty->root);
 381                                 kfree(dirty);
 382                         }
 383                 }
 384         }
 385         return err;
 386 }
 387
 388 int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
 389 {
 390         struct btrfs_fs_info *info = root->fs_info;
 391         int ret;
 392         struct btrfs_trans_handle *trans;
 393         unsigned long nr;
 394
 395         smp_mb();
 396         if (root->defrag_running)
 397                 return 0;
 398         trans = btrfs_start_transaction(root, 1);
 399         while (1) {
 400                 root->defrag_running = 1;
 401                 ret = btrfs_defrag_leaves(trans, root, cacheonly);
 402                 nr = trans->blocks_used;
 403                 btrfs_end_transaction(trans, root);
 404                 btrfs_btree_balance_dirty(info->tree_root, nr);
 405                 cond_resched();
 406
 407                 trans = btrfs_start_transaction(root, 1);
 408                 if (ret != -EAGAIN)
 409                         break;
 410         }
 411         root->defrag_running = 0;
 412         smp_mb();
 413         radix_tree_tag_clear(&info->fs_roots_radix,
 414                      (unsigned long)root->root_key.objectid,
 415                      BTRFS_ROOT_DEFRAG_TAG);
 416         btrfs_end_transaction(trans, root);
 417         return 0;
 418 }
 419
 420 int btrfs_defrag_dirty_roots(struct btrfs_fs_info *info)
 421 {
 422         struct btrfs_root *gang[1];
 423         struct btrfs_root *root;
 424         int i;
 425         int ret;
 426         int err = 0;
 427         u64 last = 0;
 428
 429         while(1) {
 430                 ret = radix_tree_gang_lookup_tag(&info->fs_roots_radix,
 431                                                  (void **)gang, last,
 432                                                  ARRAY_SIZE(gang),
 433                                                  BTRFS_ROOT_DEFRAG_TAG);
 434                 if (ret == 0)
 435                         break;
 436                 for (i = 0; i < ret; i++) {
 437                         root = gang[i];
 438                         last = root->root_key.objectid + 1;
 439                         btrfs_defrag_root(root, 1);
 440                 }
 441         }
 442         btrfs_defrag_root(info->extent_root, 1);
 443         return err;
 444 }
 445
 446 static noinline int drop_dirty_roots(struct btrfs_root *tree_root,
 447                                      struct list_head *list)
 448 {
 449         struct dirty_root *dirty;
 450         struct btrfs_trans_handle *trans;
 451         unsigned long nr;
 452         u64 num_bytes;
 453         u64 bytes_used;
 454         int ret = 0;
 455         int err;
 456
 457         while(!list_empty(list)) {
 458                 struct btrfs_root *root;
 459
 460                 dirty = list_entry(list->next, struct dirty_root, list);
 461                 list_del_init(&dirty->list);
 462
 463                 num_bytes = btrfs_root_used(&dirty->root->root_item);
 464                 root = dirty->latest_root;
 465                 atomic_inc(&root->fs_info->throttles);
 466
 467                 mutex_lock(&root->fs_info->drop_mutex);
 468                 while(1) {
 469                         trans = btrfs_start_transaction(tree_root, 1);
 470                         ret = btrfs_drop_snapshot(trans, dirty->root);
 471                         if (ret != -EAGAIN) {
 472                                 break;
 473                         }
 474
 475                         err = btrfs_update_root(trans,
 476                                         tree_root,
 477                                         &dirty->root->root_key,
 478                                         &dirty->root->root_item);
 479                         if (err)
 480                                 ret = err;
 481                         nr = trans->blocks_used;
 482                         ret = btrfs_end_transaction(trans, tree_root);
 483                         BUG_ON(ret);
 484
 485                         mutex_unlock(&root->fs_info->drop_mutex);
 486                         btrfs_btree_balance_dirty(tree_root, nr);
 487                         cond_resched();
 488                         mutex_lock(&root->fs_info->drop_mutex);
 489                 }
 490                 BUG_ON(ret);
 491                 atomic_dec(&root->fs_info->throttles);
 492
 493                 mutex_lock(&root->fs_info->alloc_mutex);
 494                 num_bytes -= btrfs_root_used(&dirty->root->root_item);
 495                 bytes_used = btrfs_root_used(&root->root_item);
 496                 if (num_bytes) {
 497                         record_root_in_trans(root);
 498                         btrfs_set_root_used(&root->root_item,
 499                                             bytes_used - num_bytes);
 500                 }
 501                 mutex_unlock(&root->fs_info->alloc_mutex);
 502
 503                 ret = btrfs_del_root(trans, tree_root, &dirty->root->root_key);
 504                 if (ret) {
 505                         BUG();
 506                         break;
 507                 }
 508                 mutex_unlock(&root->fs_info->drop_mutex);
 509
 510                 nr = trans->blocks_used;
 511                 ret = btrfs_end_transaction(trans, tree_root);
 512                 BUG_ON(ret);
 513
 514                 free_extent_buffer(dirty->root->node);
 515                 kfree(dirty->root);
 516                 kfree(dirty);
 517
 518                 btrfs_btree_balance_dirty(tree_root, nr);
 519                 cond_resched();
 520         }
 521         return ret;
 522 }
 523
 524 int btrfs_write_ordered_inodes(struct btrfs_trans_handle *trans,
 525                                 struct btrfs_root *root)
 526 {
 527         struct btrfs_transaction *cur_trans = trans->transaction;
 528         struct inode *inode;
 529         u64 root_objectid = 0;
 530         u64 objectid = 0;
 531         int ret;
 532
 533         atomic_inc(&root->fs_info->throttles);
 534         while(1) {
 535                 ret = btrfs_find_first_ordered_inode(
 536                                 &cur_trans->ordered_inode_tree,
 537                                 &root_objectid, &objectid, &inode);
 538                 if (!ret)
 539                         break;
 540
 541                 mutex_unlock(&root->fs_info->trans_mutex);
 542
 543                 if (S_ISREG(inode->i_mode)) {
 544                         atomic_inc(&BTRFS_I(inode)->ordered_writeback);
 545                         filemap_fdatawrite(inode->i_mapping);
 546                         atomic_dec(&BTRFS_I(inode)->ordered_writeback);
 547                 }
 548                 iput(inode);
 549
 550                 mutex_lock(&root->fs_info->trans_mutex);
 551         }
 552         while(1) {
 553                 root_objectid = 0;
 554                 objectid = 0;
 555                 ret = btrfs_find_del_first_ordered_inode(
 556                                 &cur_trans->ordered_inode_tree,
 557                                 &root_objectid, &objectid, &inode);
 558                 if (!ret)
 559                         break;
 560                 mutex_unlock(&root->fs_info->trans_mutex);
 561
 562                 if (S_ISREG(inode->i_mode)) {
 563                         atomic_inc(&BTRFS_I(inode)->ordered_writeback);
 564                         filemap_write_and_wait(inode->i_mapping);
 565                         atomic_dec(&BTRFS_I(inode)->ordered_writeback);
 566                 }
 567                 atomic_dec(&inode->i_count);
 568                 iput(inode);
 569
 570                 mutex_lock(&root->fs_info->trans_mutex);
 571         }
 572         atomic_dec(&root->fs_info->throttles);
 573         return 0;
 574 }
 575
 576 static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
 577                                    struct btrfs_fs_info *fs_info,
 578                                    struct btrfs_pending_snapshot *pending)
 579 {
 580         struct btrfs_key key;
 581         struct btrfs_root_item *new_root_item;
 582         struct btrfs_root *tree_root = fs_info->tree_root;
 583         struct btrfs_root *root = pending->root;
 584         struct extent_buffer *tmp;
 585         struct extent_buffer *old;
 586         int ret;
 587         int namelen;
 588         u64 objectid;
 589
 590         new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
 591         if (!new_root_item) {
 592                 ret = -ENOMEM;
 593                 goto fail;
 594         }
 595         ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid);
 596         if (ret)
 597                 goto fail;
 598
 599         memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
 600
 601         key.objectid = objectid;
 602         key.offset = 1;
 603         btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
 604
 605         old = btrfs_lock_root_node(root);
 606         btrfs_cow_block(trans, root, old, NULL, 0, &old);
 607
 608         btrfs_copy_root(trans, root, old, &tmp, objectid);
 609         btrfs_tree_unlock(old);
 610         free_extent_buffer(old);
 611
 612         btrfs_set_root_bytenr(new_root_item, tmp->start);
 613         btrfs_set_root_level(new_root_item, btrfs_header_level(tmp));
 614         ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
 615                                 new_root_item);
 616         btrfs_tree_unlock(tmp);
 617         free_extent_buffer(tmp);
 618         if (ret)
 619                 goto fail;
 620
 621         /*
 622          * insert the directory item
 623          */
 624         key.offset = (u64)-1;
 625         namelen = strlen(pending->name);
 626         ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
 627                                     pending->name, namelen,
 628                                     root->fs_info->sb->s_root->d_inode->i_ino,
 629                                     &key, BTRFS_FT_DIR);
 630
 631         if (ret)
 632                 goto fail;
 633
 634         ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root,
 635                              pending->name, strlen(pending->name), objectid,
 636                              root->fs_info->sb->s_root->d_inode->i_ino);
 637
 638         /* Invalidate existing dcache entry for new snapshot. */
 639         btrfs_invalidate_dcache_root(root, pending->name, namelen);
 640
 641 fail:
 642         kfree(new_root_item);
 643         return ret;
 644 }
 645
 646 static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
 647                                              struct btrfs_fs_info *fs_info)
 648 {
 649         struct btrfs_pending_snapshot *pending;
 650         struct list_head *head = &trans->transaction->pending_snapshots;
 651         int ret;
 652
 653         while(!list_empty(head)) {
 654                 pending = list_entry(head->next,
 655                                      struct btrfs_pending_snapshot, list);
 656                 ret = create_pending_snapshot(trans, fs_info, pending);
 657                 BUG_ON(ret);
 658                 list_del(&pending->list);
 659                 kfree(pending->name);
 660                 kfree(pending);
 661         }
 662         return 0;
 663 }
 664
 665 int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
 666                              struct btrfs_root *root)
 667 {
 668         unsigned long joined = 0;
 669         unsigned long timeout = 1;
 670         struct btrfs_transaction *cur_trans;
 671         struct btrfs_transaction *prev_trans = NULL;
 672         struct btrfs_root *chunk_root = root->fs_info->chunk_root;
 673         struct list_head dirty_fs_roots;
 674         struct extent_io_tree *pinned_copy;
 675         DEFINE_WAIT(wait);
 676         int ret;
 677
 678         INIT_LIST_HEAD(&dirty_fs_roots);
 679
 680         mutex_lock(&root->fs_info->trans_mutex);
 681         if (trans->transaction->in_commit) {
 682                 cur_trans = trans->transaction;
 683                 trans->transaction->use_count++;
 684                 mutex_unlock(&root->fs_info->trans_mutex);
 685                 btrfs_end_transaction(trans, root);
 686
 687                 ret = wait_for_commit(root, cur_trans);
 688                 BUG_ON(ret);
 689
 690                 mutex_lock(&root->fs_info->trans_mutex);
 691                 put_transaction(cur_trans);
 692                 mutex_unlock(&root->fs_info->trans_mutex);
 693
 694                 return 0;
 695         }
 696
 697         pinned_copy = kmalloc(sizeof(*pinned_copy), GFP_NOFS);
 698         if (!pinned_copy)
 699                 return -ENOMEM;
 700
 701         extent_io_tree_init(pinned_copy,
 702                              root->fs_info->btree_inode->i_mapping, GFP_NOFS);
 703
 704         trans->transaction->in_commit = 1;
 705 printk("trans %Lu in commit\n", trans->transid);
 706         cur_trans = trans->transaction;
 707         if (cur_trans->list.prev != &root->fs_info->trans_list) {
 708                 prev_trans = list_entry(cur_trans->list.prev,
 709                                         struct btrfs_transaction, list);
 710                 if (!prev_trans->commit_done) {
 711                         prev_trans->use_count++;
 712                         mutex_unlock(&root->fs_info->trans_mutex);
 713
 714                         wait_for_commit(root, prev_trans);
 715
 716                         mutex_lock(&root->fs_info->trans_mutex);
 717                         put_transaction(prev_trans);
 718                 }
 719         }
 720
 721         do {
 722                 joined = cur_trans->num_joined;
 723                 WARN_ON(cur_trans != trans->transaction);
 724                 prepare_to_wait(&cur_trans->writer_wait, &wait,
 725                                 TASK_UNINTERRUPTIBLE);
 726
 727                 if (cur_trans->num_writers > 1)
 728                         timeout = MAX_SCHEDULE_TIMEOUT;
 729                 else
 730                         timeout = 1;
 731
 732                 mutex_unlock(&root->fs_info->trans_mutex);
 733
 734                 schedule_timeout(timeout);
 735
 736                 mutex_lock(&root->fs_info->trans_mutex);
 737                 finish_wait(&cur_trans->writer_wait, &wait);
 738                 ret = btrfs_write_ordered_inodes(trans, root);
 739
 740         } while (cur_trans->num_writers > 1 ||
 741                  (cur_trans->num_joined != joined));
 742
 743         ret = create_pending_snapshots(trans, root->fs_info);
 744         BUG_ON(ret);
 745
 746         WARN_ON(cur_trans != trans->transaction);
 747
 748         ret = add_dirty_roots(trans, &root->fs_info->fs_roots_radix,
 749                               &dirty_fs_roots);
 750         BUG_ON(ret);
 751
 752         ret = btrfs_commit_tree_roots(trans, root);
 753         BUG_ON(ret);
 754
 755         cur_trans = root->fs_info->running_transaction;
 756         spin_lock(&root->fs_info->new_trans_lock);
 757         root->fs_info->running_transaction = NULL;
 758         spin_unlock(&root->fs_info->new_trans_lock);
 759         btrfs_set_super_generation(&root->fs_info->super_copy,
 760                                    cur_trans->transid);
 761         btrfs_set_super_root(&root->fs_info->super_copy,
 762                              root->fs_info->tree_root->node->start);
 763         btrfs_set_super_root_level(&root->fs_info->super_copy,
 764                            btrfs_header_level(root->fs_info->tree_root->node));
 765
 766         btrfs_set_super_chunk_root(&root->fs_info->super_copy,
 767                                    chunk_root->node->start);
 768         btrfs_set_super_chunk_root_level(&root->fs_info->super_copy,
 769                                          btrfs_header_level(chunk_root->node));
 770         memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
 771                sizeof(root->fs_info->super_copy));
 772
 773         btrfs_copy_pinned(root, pinned_copy);
 774
 775         mutex_unlock(&root->fs_info->trans_mutex);
 776         ret = btrfs_write_and_wait_transaction(trans, root);
 777         BUG_ON(ret);
 778         write_ctree_super(trans, root);
 779
 780         btrfs_finish_extent_commit(trans, root, pinned_copy);
 781         mutex_lock(&root->fs_info->trans_mutex);
 782
 783         kfree(pinned_copy);
 784
 785         cur_trans->commit_done = 1;
 786 printk("trans %Lu done in commit\n", cur_trans->transid);
 787         root->fs_info->last_trans_committed = cur_trans->transid;
 788         wake_up(&cur_trans->commit_wait);
 789         put_transaction(cur_trans);
 790         put_transaction(cur_trans);
 791
 792         if (root->fs_info->closing)
 793                 list_splice_init(&root->fs_info->dead_roots, &dirty_fs_roots);
 794         else
 795                 list_splice_init(&dirty_fs_roots, &root->fs_info->dead_roots);
 796
 797         mutex_unlock(&root->fs_info->trans_mutex);
 798         kmem_cache_free(btrfs_trans_handle_cachep, trans);
 799
 800         if (root->fs_info->closing) {
 801                 drop_dirty_roots(root->fs_info->tree_root, &dirty_fs_roots);
 802         }
 803         return ret;
 804 }
 805
 806 int btrfs_clean_old_snapshots(struct btrfs_root *root)
 807 {
 808         struct list_head dirty_roots;
 809         INIT_LIST_HEAD(&dirty_roots);
 810
 811         mutex_lock(&root->fs_info->trans_mutex);
 812         list_splice_init(&root->fs_info->dead_roots, &dirty_roots);
 813         mutex_unlock(&root->fs_info->trans_mutex);
 814
 815         if (!list_empty(&dirty_roots)) {
 816                 drop_dirty_roots(root, &dirty_roots);
 817         }
 818         return 0;
 819 }
 820 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
 821 void btrfs_transaction_cleaner(void *p)
 822 #else
 823 void btrfs_transaction_cleaner(struct work_struct *work)
 824 #endif
 825 {
 826 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
 827         struct btrfs_fs_info *fs_info = p;
 828 #else
 829         struct btrfs_fs_info *fs_info = container_of(work,
 830                                                      struct btrfs_fs_info,
 831                                                      trans_work.work);
 832
 833 #endif
 834         struct btrfs_root *root = fs_info->tree_root;
 835         struct btrfs_transaction *cur;
 836         struct btrfs_trans_handle *trans;
 837         unsigned long now;
 838         unsigned long delay = HZ * 30;
 839         int ret;
 840
 841         smp_mb();
 842         if (root->fs_info->closing)
 843                 goto out;
 844
 845         mutex_lock(&root->fs_info->trans_mutex);
 846         cur = root->fs_info->running_transaction;
 847         if (!cur) {
 848                 mutex_unlock(&root->fs_info->trans_mutex);
 849                 goto out;
 850         }
 851         now = get_seconds();
 852         if (now < cur->start_time || now - cur->start_time < 30) {
 853                 mutex_unlock(&root->fs_info->trans_mutex);
 854                 delay = HZ * 5;
 855                 goto out;
 856         }
 857         mutex_unlock(&root->fs_info->trans_mutex);
 858         btrfs_defrag_dirty_roots(root->fs_info);
 859         trans = btrfs_start_transaction(root, 1);
 860         ret = btrfs_commit_transaction(trans, root);
 861 out:
 862         btrfs_clean_old_snapshots(root);
 863         btrfs_transaction_queue_work(root, delay);
 864 }
 865
 866 void btrfs_transaction_queue_work(struct btrfs_root *root, int delay)
 867 {
 868         if (!root->fs_info->closing)
 869                 queue_delayed_work(trans_wq, &root->fs_info->trans_work, delay);
 870 }
 871
 872 void btrfs_transaction_flush_work(struct btrfs_root *root)
 873 {
 874         cancel_delayed_work(&root->fs_info->trans_work);
 875         flush_workqueue(trans_wq);
 876 }
 877
 878 void __init btrfs_init_transaction_sys(void)
 879 {
 880         trans_wq = create_workqueue("btrfs-transaction");
 881 }
 882
 883 void btrfs_exit_transaction_sys(void)
 884 {
 885         destroy_workqueue(trans_wq);
 886 }
 887