jbd: Issue cache flush after checkpointing
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / fs / btrfs / transaction.c
blob81376d94cd3c6a4639ebef35df501dbefbfb2435
1 /*
2 * Copyright (C) 2007 Oracle. All rights reserved.
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.
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.
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.
19 #include <linux/fs.h>
20 #include <linux/slab.h>
21 #include <linux/sched.h>
22 #include <linux/writeback.h>
23 #include <linux/pagemap.h>
24 #include <linux/blkdev.h>
25 #include "ctree.h"
26 #include "disk-io.h"
27 #include "transaction.h"
28 #include "locking.h"
29 #include "tree-log.h"
30 #include "inode-map.h"
32 #define BTRFS_ROOT_TRANS_TAG 0
34 static noinline void put_transaction(struct btrfs_transaction *transaction)
36 WARN_ON(atomic_read(&transaction->use_count) == 0);
37 if (atomic_dec_and_test(&transaction->use_count)) {
38 BUG_ON(!list_empty(&transaction->list));
39 memset(transaction, 0, sizeof(*transaction));
40 kmem_cache_free(btrfs_transaction_cachep, transaction);
44 static noinline void switch_commit_root(struct btrfs_root *root)
46 free_extent_buffer(root->commit_root);
47 root->commit_root = btrfs_root_node(root);
51 * either allocate a new transaction or hop into the existing one
53 static noinline int join_transaction(struct btrfs_root *root, int nofail)
55 struct btrfs_transaction *cur_trans;
57 spin_lock(&root->fs_info->trans_lock);
58 loop:
59 if (root->fs_info->trans_no_join) {
60 if (!nofail) {
61 spin_unlock(&root->fs_info->trans_lock);
62 return -EBUSY;
66 cur_trans = root->fs_info->running_transaction;
67 if (cur_trans) {
68 atomic_inc(&cur_trans->use_count);
69 atomic_inc(&cur_trans->num_writers);
70 cur_trans->num_joined++;
71 spin_unlock(&root->fs_info->trans_lock);
72 return 0;
74 spin_unlock(&root->fs_info->trans_lock);
76 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
77 if (!cur_trans)
78 return -ENOMEM;
80 spin_lock(&root->fs_info->trans_lock);
81 if (root->fs_info->running_transaction) {
83 * someone started a transaction after we unlocked. Make sure
84 * to redo the trans_no_join checks above
86 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
87 cur_trans = root->fs_info->running_transaction;
88 goto loop;
91 atomic_set(&cur_trans->num_writers, 1);
92 cur_trans->num_joined = 0;
93 init_waitqueue_head(&cur_trans->writer_wait);
94 init_waitqueue_head(&cur_trans->commit_wait);
95 cur_trans->in_commit = 0;
96 cur_trans->blocked = 0;
98 * One for this trans handle, one so it will live on until we
99 * commit the transaction.
101 atomic_set(&cur_trans->use_count, 2);
102 cur_trans->commit_done = 0;
103 cur_trans->start_time = get_seconds();
105 cur_trans->delayed_refs.root = RB_ROOT;
106 cur_trans->delayed_refs.num_entries = 0;
107 cur_trans->delayed_refs.num_heads_ready = 0;
108 cur_trans->delayed_refs.num_heads = 0;
109 cur_trans->delayed_refs.flushing = 0;
110 cur_trans->delayed_refs.run_delayed_start = 0;
111 spin_lock_init(&cur_trans->commit_lock);
112 spin_lock_init(&cur_trans->delayed_refs.lock);
114 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
115 list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
116 extent_io_tree_init(&cur_trans->dirty_pages,
117 root->fs_info->btree_inode->i_mapping);
118 root->fs_info->generation++;
119 cur_trans->transid = root->fs_info->generation;
120 root->fs_info->running_transaction = cur_trans;
121 spin_unlock(&root->fs_info->trans_lock);
123 return 0;
127 * this does all the record keeping required to make sure that a reference
128 * counted root is properly recorded in a given transaction. This is required
129 * to make sure the old root from before we joined the transaction is deleted
130 * when the transaction commits
132 static int record_root_in_trans(struct btrfs_trans_handle *trans,
133 struct btrfs_root *root)
135 if (root->ref_cows && root->last_trans < trans->transid) {
136 WARN_ON(root == root->fs_info->extent_root);
137 WARN_ON(root->commit_root != root->node);
140 * see below for in_trans_setup usage rules
141 * we have the reloc mutex held now, so there
142 * is only one writer in this function
144 root->in_trans_setup = 1;
146 /* make sure readers find in_trans_setup before
147 * they find our root->last_trans update
149 smp_wmb();
151 spin_lock(&root->fs_info->fs_roots_radix_lock);
152 if (root->last_trans == trans->transid) {
153 spin_unlock(&root->fs_info->fs_roots_radix_lock);
154 return 0;
156 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
157 (unsigned long)root->root_key.objectid,
158 BTRFS_ROOT_TRANS_TAG);
159 spin_unlock(&root->fs_info->fs_roots_radix_lock);
160 root->last_trans = trans->transid;
162 /* this is pretty tricky. We don't want to
163 * take the relocation lock in btrfs_record_root_in_trans
164 * unless we're really doing the first setup for this root in
165 * this transaction.
167 * Normally we'd use root->last_trans as a flag to decide
168 * if we want to take the expensive mutex.
170 * But, we have to set root->last_trans before we
171 * init the relocation root, otherwise, we trip over warnings
172 * in ctree.c. The solution used here is to flag ourselves
173 * with root->in_trans_setup. When this is 1, we're still
174 * fixing up the reloc trees and everyone must wait.
176 * When this is zero, they can trust root->last_trans and fly
177 * through btrfs_record_root_in_trans without having to take the
178 * lock. smp_wmb() makes sure that all the writes above are
179 * done before we pop in the zero below
181 btrfs_init_reloc_root(trans, root);
182 smp_wmb();
183 root->in_trans_setup = 0;
185 return 0;
189 int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
190 struct btrfs_root *root)
192 if (!root->ref_cows)
193 return 0;
196 * see record_root_in_trans for comments about in_trans_setup usage
197 * and barriers
199 smp_rmb();
200 if (root->last_trans == trans->transid &&
201 !root->in_trans_setup)
202 return 0;
204 mutex_lock(&root->fs_info->reloc_mutex);
205 record_root_in_trans(trans, root);
206 mutex_unlock(&root->fs_info->reloc_mutex);
208 return 0;
211 /* wait for commit against the current transaction to become unblocked
212 * when this is done, it is safe to start a new transaction, but the current
213 * transaction might not be fully on disk.
215 static void wait_current_trans(struct btrfs_root *root)
217 struct btrfs_transaction *cur_trans;
219 spin_lock(&root->fs_info->trans_lock);
220 cur_trans = root->fs_info->running_transaction;
221 if (cur_trans && cur_trans->blocked) {
222 atomic_inc(&cur_trans->use_count);
223 spin_unlock(&root->fs_info->trans_lock);
225 wait_event(root->fs_info->transaction_wait,
226 !cur_trans->blocked);
227 put_transaction(cur_trans);
228 } else {
229 spin_unlock(&root->fs_info->trans_lock);
233 enum btrfs_trans_type {
234 TRANS_START,
235 TRANS_JOIN,
236 TRANS_USERSPACE,
237 TRANS_JOIN_NOLOCK,
240 static int may_wait_transaction(struct btrfs_root *root, int type)
242 if (root->fs_info->log_root_recovering)
243 return 0;
245 if (type == TRANS_USERSPACE)
246 return 1;
248 if (type == TRANS_START &&
249 !atomic_read(&root->fs_info->open_ioctl_trans))
250 return 1;
252 return 0;
255 static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
256 u64 num_items, int type)
258 struct btrfs_trans_handle *h;
259 struct btrfs_transaction *cur_trans;
260 u64 num_bytes = 0;
261 int ret;
263 if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
264 return ERR_PTR(-EROFS);
266 if (current->journal_info) {
267 WARN_ON(type != TRANS_JOIN && type != TRANS_JOIN_NOLOCK);
268 h = current->journal_info;
269 h->use_count++;
270 h->orig_rsv = h->block_rsv;
271 h->block_rsv = NULL;
272 goto got_it;
276 * Do the reservation before we join the transaction so we can do all
277 * the appropriate flushing if need be.
279 if (num_items > 0 && root != root->fs_info->chunk_root) {
280 num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
281 ret = btrfs_block_rsv_add(root,
282 &root->fs_info->trans_block_rsv,
283 num_bytes);
284 if (ret)
285 return ERR_PTR(ret);
287 again:
288 h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
289 if (!h)
290 return ERR_PTR(-ENOMEM);
292 if (may_wait_transaction(root, type))
293 wait_current_trans(root);
295 do {
296 ret = join_transaction(root, type == TRANS_JOIN_NOLOCK);
297 if (ret == -EBUSY)
298 wait_current_trans(root);
299 } while (ret == -EBUSY);
301 if (ret < 0) {
302 kmem_cache_free(btrfs_trans_handle_cachep, h);
303 return ERR_PTR(ret);
306 cur_trans = root->fs_info->running_transaction;
308 h->transid = cur_trans->transid;
309 h->transaction = cur_trans;
310 h->blocks_used = 0;
311 h->bytes_reserved = 0;
312 h->delayed_ref_updates = 0;
313 h->use_count = 1;
314 h->block_rsv = NULL;
315 h->orig_rsv = NULL;
317 smp_mb();
318 if (cur_trans->blocked && may_wait_transaction(root, type)) {
319 btrfs_commit_transaction(h, root);
320 goto again;
323 if (num_bytes) {
324 h->block_rsv = &root->fs_info->trans_block_rsv;
325 h->bytes_reserved = num_bytes;
328 got_it:
329 btrfs_record_root_in_trans(h, root);
331 if (!current->journal_info && type != TRANS_USERSPACE)
332 current->journal_info = h;
333 return h;
336 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
337 int num_items)
339 return start_transaction(root, num_items, TRANS_START);
341 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
343 return start_transaction(root, 0, TRANS_JOIN);
346 struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
348 return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
351 struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
353 return start_transaction(root, 0, TRANS_USERSPACE);
356 /* wait for a transaction commit to be fully complete */
357 static noinline void wait_for_commit(struct btrfs_root *root,
358 struct btrfs_transaction *commit)
360 wait_event(commit->commit_wait, commit->commit_done);
363 int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
365 struct btrfs_transaction *cur_trans = NULL, *t;
366 int ret;
368 ret = 0;
369 if (transid) {
370 if (transid <= root->fs_info->last_trans_committed)
371 goto out;
373 /* find specified transaction */
374 spin_lock(&root->fs_info->trans_lock);
375 list_for_each_entry(t, &root->fs_info->trans_list, list) {
376 if (t->transid == transid) {
377 cur_trans = t;
378 atomic_inc(&cur_trans->use_count);
379 break;
381 if (t->transid > transid)
382 break;
384 spin_unlock(&root->fs_info->trans_lock);
385 ret = -EINVAL;
386 if (!cur_trans)
387 goto out; /* bad transid */
388 } else {
389 /* find newest transaction that is committing | committed */
390 spin_lock(&root->fs_info->trans_lock);
391 list_for_each_entry_reverse(t, &root->fs_info->trans_list,
392 list) {
393 if (t->in_commit) {
394 if (t->commit_done)
395 break;
396 cur_trans = t;
397 atomic_inc(&cur_trans->use_count);
398 break;
401 spin_unlock(&root->fs_info->trans_lock);
402 if (!cur_trans)
403 goto out; /* nothing committing|committed */
406 wait_for_commit(root, cur_trans);
408 put_transaction(cur_trans);
409 ret = 0;
410 out:
411 return ret;
414 void btrfs_throttle(struct btrfs_root *root)
416 if (!atomic_read(&root->fs_info->open_ioctl_trans))
417 wait_current_trans(root);
420 static int should_end_transaction(struct btrfs_trans_handle *trans,
421 struct btrfs_root *root)
423 int ret;
425 ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
426 return ret ? 1 : 0;
429 int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
430 struct btrfs_root *root)
432 struct btrfs_transaction *cur_trans = trans->transaction;
433 struct btrfs_block_rsv *rsv = trans->block_rsv;
434 int updates;
436 smp_mb();
437 if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
438 return 1;
441 * We need to do this in case we're deleting csums so the global block
442 * rsv get's used instead of the csum block rsv.
444 trans->block_rsv = NULL;
446 updates = trans->delayed_ref_updates;
447 trans->delayed_ref_updates = 0;
448 if (updates)
449 btrfs_run_delayed_refs(trans, root, updates);
451 trans->block_rsv = rsv;
453 return should_end_transaction(trans, root);
456 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
457 struct btrfs_root *root, int throttle, int lock)
459 struct btrfs_transaction *cur_trans = trans->transaction;
460 struct btrfs_fs_info *info = root->fs_info;
461 int count = 0;
463 if (--trans->use_count) {
464 trans->block_rsv = trans->orig_rsv;
465 return 0;
468 btrfs_trans_release_metadata(trans, root);
469 trans->block_rsv = NULL;
470 while (count < 4) {
471 unsigned long cur = trans->delayed_ref_updates;
472 trans->delayed_ref_updates = 0;
473 if (cur &&
474 trans->transaction->delayed_refs.num_heads_ready > 64) {
475 trans->delayed_ref_updates = 0;
478 * do a full flush if the transaction is trying
479 * to close
481 if (trans->transaction->delayed_refs.flushing)
482 cur = 0;
483 btrfs_run_delayed_refs(trans, root, cur);
484 } else {
485 break;
487 count++;
490 if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
491 should_end_transaction(trans, root)) {
492 trans->transaction->blocked = 1;
493 smp_wmb();
496 if (lock && cur_trans->blocked && !cur_trans->in_commit) {
497 if (throttle) {
499 * We may race with somebody else here so end up having
500 * to call end_transaction on ourselves again, so inc
501 * our use_count.
503 trans->use_count++;
504 return btrfs_commit_transaction(trans, root);
505 } else {
506 wake_up_process(info->transaction_kthread);
510 WARN_ON(cur_trans != info->running_transaction);
511 WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
512 atomic_dec(&cur_trans->num_writers);
514 smp_mb();
515 if (waitqueue_active(&cur_trans->writer_wait))
516 wake_up(&cur_trans->writer_wait);
517 put_transaction(cur_trans);
519 if (current->journal_info == trans)
520 current->journal_info = NULL;
521 memset(trans, 0, sizeof(*trans));
522 kmem_cache_free(btrfs_trans_handle_cachep, trans);
524 if (throttle)
525 btrfs_run_delayed_iputs(root);
527 return 0;
530 int btrfs_end_transaction(struct btrfs_trans_handle *trans,
531 struct btrfs_root *root)
533 int ret;
535 ret = __btrfs_end_transaction(trans, root, 0, 1);
536 if (ret)
537 return ret;
538 return 0;
541 int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
542 struct btrfs_root *root)
544 int ret;
546 ret = __btrfs_end_transaction(trans, root, 1, 1);
547 if (ret)
548 return ret;
549 return 0;
552 int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
553 struct btrfs_root *root)
555 int ret;
557 ret = __btrfs_end_transaction(trans, root, 0, 0);
558 if (ret)
559 return ret;
560 return 0;
563 int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans,
564 struct btrfs_root *root)
566 return __btrfs_end_transaction(trans, root, 1, 1);
570 * when btree blocks are allocated, they have some corresponding bits set for
571 * them in one of two extent_io trees. This is used to make sure all of
572 * those extents are sent to disk but does not wait on them
574 int btrfs_write_marked_extents(struct btrfs_root *root,
575 struct extent_io_tree *dirty_pages, int mark)
577 int err = 0;
578 int werr = 0;
579 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
580 u64 start = 0;
581 u64 end;
583 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
584 mark)) {
585 convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT, mark,
586 GFP_NOFS);
587 err = filemap_fdatawrite_range(mapping, start, end);
588 if (err)
589 werr = err;
590 cond_resched();
591 start = end + 1;
593 if (err)
594 werr = err;
595 return werr;
599 * when btree blocks are allocated, they have some corresponding bits set for
600 * them in one of two extent_io trees. This is used to make sure all of
601 * those extents are on disk for transaction or log commit. We wait
602 * on all the pages and clear them from the dirty pages state tree
604 int btrfs_wait_marked_extents(struct btrfs_root *root,
605 struct extent_io_tree *dirty_pages, int mark)
607 int err = 0;
608 int werr = 0;
609 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
610 u64 start = 0;
611 u64 end;
613 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
614 EXTENT_NEED_WAIT)) {
615 clear_extent_bits(dirty_pages, start, end, EXTENT_NEED_WAIT, GFP_NOFS);
616 err = filemap_fdatawait_range(mapping, start, end);
617 if (err)
618 werr = err;
619 cond_resched();
620 start = end + 1;
622 if (err)
623 werr = err;
624 return werr;
628 * when btree blocks are allocated, they have some corresponding bits set for
629 * them in one of two extent_io trees. This is used to make sure all of
630 * those extents are on disk for transaction or log commit
632 int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
633 struct extent_io_tree *dirty_pages, int mark)
635 int ret;
636 int ret2;
638 ret = btrfs_write_marked_extents(root, dirty_pages, mark);
639 ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
641 if (ret)
642 return ret;
643 if (ret2)
644 return ret2;
645 return 0;
648 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
649 struct btrfs_root *root)
651 if (!trans || !trans->transaction) {
652 struct inode *btree_inode;
653 btree_inode = root->fs_info->btree_inode;
654 return filemap_write_and_wait(btree_inode->i_mapping);
656 return btrfs_write_and_wait_marked_extents(root,
657 &trans->transaction->dirty_pages,
658 EXTENT_DIRTY);
662 * this is used to update the root pointer in the tree of tree roots.
664 * But, in the case of the extent allocation tree, updating the root
665 * pointer may allocate blocks which may change the root of the extent
666 * allocation tree.
668 * So, this loops and repeats and makes sure the cowonly root didn't
669 * change while the root pointer was being updated in the metadata.
671 static int update_cowonly_root(struct btrfs_trans_handle *trans,
672 struct btrfs_root *root)
674 int ret;
675 u64 old_root_bytenr;
676 u64 old_root_used;
677 struct btrfs_root *tree_root = root->fs_info->tree_root;
679 old_root_used = btrfs_root_used(&root->root_item);
680 btrfs_write_dirty_block_groups(trans, root);
682 while (1) {
683 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
684 if (old_root_bytenr == root->node->start &&
685 old_root_used == btrfs_root_used(&root->root_item))
686 break;
688 btrfs_set_root_node(&root->root_item, root->node);
689 ret = btrfs_update_root(trans, tree_root,
690 &root->root_key,
691 &root->root_item);
692 BUG_ON(ret);
694 old_root_used = btrfs_root_used(&root->root_item);
695 ret = btrfs_write_dirty_block_groups(trans, root);
696 BUG_ON(ret);
699 if (root != root->fs_info->extent_root)
700 switch_commit_root(root);
702 return 0;
706 * update all the cowonly tree roots on disk
708 static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
709 struct btrfs_root *root)
711 struct btrfs_fs_info *fs_info = root->fs_info;
712 struct list_head *next;
713 struct extent_buffer *eb;
714 int ret;
716 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
717 BUG_ON(ret);
719 eb = btrfs_lock_root_node(fs_info->tree_root);
720 btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
721 btrfs_tree_unlock(eb);
722 free_extent_buffer(eb);
724 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
725 BUG_ON(ret);
727 while (!list_empty(&fs_info->dirty_cowonly_roots)) {
728 next = fs_info->dirty_cowonly_roots.next;
729 list_del_init(next);
730 root = list_entry(next, struct btrfs_root, dirty_list);
732 update_cowonly_root(trans, root);
735 down_write(&fs_info->extent_commit_sem);
736 switch_commit_root(fs_info->extent_root);
737 up_write(&fs_info->extent_commit_sem);
739 return 0;
743 * dead roots are old snapshots that need to be deleted. This allocates
744 * a dirty root struct and adds it into the list of dead roots that need to
745 * be deleted
747 int btrfs_add_dead_root(struct btrfs_root *root)
749 spin_lock(&root->fs_info->trans_lock);
750 list_add(&root->root_list, &root->fs_info->dead_roots);
751 spin_unlock(&root->fs_info->trans_lock);
752 return 0;
756 * update all the cowonly tree roots on disk
758 static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
759 struct btrfs_root *root)
761 struct btrfs_root *gang[8];
762 struct btrfs_fs_info *fs_info = root->fs_info;
763 int i;
764 int ret;
765 int err = 0;
767 spin_lock(&fs_info->fs_roots_radix_lock);
768 while (1) {
769 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
770 (void **)gang, 0,
771 ARRAY_SIZE(gang),
772 BTRFS_ROOT_TRANS_TAG);
773 if (ret == 0)
774 break;
775 for (i = 0; i < ret; i++) {
776 root = gang[i];
777 radix_tree_tag_clear(&fs_info->fs_roots_radix,
778 (unsigned long)root->root_key.objectid,
779 BTRFS_ROOT_TRANS_TAG);
780 spin_unlock(&fs_info->fs_roots_radix_lock);
782 btrfs_free_log(trans, root);
783 btrfs_update_reloc_root(trans, root);
784 btrfs_orphan_commit_root(trans, root);
786 btrfs_save_ino_cache(root, trans);
788 /* see comments in should_cow_block() */
789 root->force_cow = 0;
790 smp_wmb();
792 if (root->commit_root != root->node) {
793 mutex_lock(&root->fs_commit_mutex);
794 switch_commit_root(root);
795 btrfs_unpin_free_ino(root);
796 mutex_unlock(&root->fs_commit_mutex);
798 btrfs_set_root_node(&root->root_item,
799 root->node);
802 err = btrfs_update_root(trans, fs_info->tree_root,
803 &root->root_key,
804 &root->root_item);
805 spin_lock(&fs_info->fs_roots_radix_lock);
806 if (err)
807 break;
810 spin_unlock(&fs_info->fs_roots_radix_lock);
811 return err;
815 * defrag a given btree. If cacheonly == 1, this won't read from the disk,
816 * otherwise every leaf in the btree is read and defragged.
818 int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
820 struct btrfs_fs_info *info = root->fs_info;
821 struct btrfs_trans_handle *trans;
822 int ret;
823 unsigned long nr;
825 if (xchg(&root->defrag_running, 1))
826 return 0;
828 while (1) {
829 trans = btrfs_start_transaction(root, 0);
830 if (IS_ERR(trans))
831 return PTR_ERR(trans);
833 ret = btrfs_defrag_leaves(trans, root, cacheonly);
835 nr = trans->blocks_used;
836 btrfs_end_transaction(trans, root);
837 btrfs_btree_balance_dirty(info->tree_root, nr);
838 cond_resched();
840 if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
841 break;
843 root->defrag_running = 0;
844 return ret;
848 * new snapshots need to be created at a very specific time in the
849 * transaction commit. This does the actual creation
851 static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
852 struct btrfs_fs_info *fs_info,
853 struct btrfs_pending_snapshot *pending)
855 struct btrfs_key key;
856 struct btrfs_root_item *new_root_item;
857 struct btrfs_root *tree_root = fs_info->tree_root;
858 struct btrfs_root *root = pending->root;
859 struct btrfs_root *parent_root;
860 struct btrfs_block_rsv *rsv;
861 struct inode *parent_inode;
862 struct dentry *parent;
863 struct dentry *dentry;
864 struct extent_buffer *tmp;
865 struct extent_buffer *old;
866 int ret;
867 u64 to_reserve = 0;
868 u64 index = 0;
869 u64 objectid;
870 u64 root_flags;
872 rsv = trans->block_rsv;
874 new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
875 if (!new_root_item) {
876 pending->error = -ENOMEM;
877 goto fail;
880 ret = btrfs_find_free_objectid(tree_root, &objectid);
881 if (ret) {
882 pending->error = ret;
883 goto fail;
886 btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
888 if (to_reserve > 0) {
889 ret = btrfs_block_rsv_add_noflush(root, &pending->block_rsv,
890 to_reserve);
891 if (ret) {
892 pending->error = ret;
893 goto fail;
897 key.objectid = objectid;
898 key.offset = (u64)-1;
899 key.type = BTRFS_ROOT_ITEM_KEY;
901 trans->block_rsv = &pending->block_rsv;
903 dentry = pending->dentry;
904 parent = dget_parent(dentry);
905 parent_inode = parent->d_inode;
906 parent_root = BTRFS_I(parent_inode)->root;
907 record_root_in_trans(trans, parent_root);
910 * insert the directory item
912 ret = btrfs_set_inode_index(parent_inode, &index);
913 BUG_ON(ret);
914 ret = btrfs_insert_dir_item(trans, parent_root,
915 dentry->d_name.name, dentry->d_name.len,
916 parent_inode, &key,
917 BTRFS_FT_DIR, index);
918 BUG_ON(ret);
920 btrfs_i_size_write(parent_inode, parent_inode->i_size +
921 dentry->d_name.len * 2);
922 ret = btrfs_update_inode(trans, parent_root, parent_inode);
923 BUG_ON(ret);
926 * pull in the delayed directory update
927 * and the delayed inode item
928 * otherwise we corrupt the FS during
929 * snapshot
931 ret = btrfs_run_delayed_items(trans, root);
932 BUG_ON(ret);
934 record_root_in_trans(trans, root);
935 btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
936 memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
937 btrfs_check_and_init_root_item(new_root_item);
939 root_flags = btrfs_root_flags(new_root_item);
940 if (pending->readonly)
941 root_flags |= BTRFS_ROOT_SUBVOL_RDONLY;
942 else
943 root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY;
944 btrfs_set_root_flags(new_root_item, root_flags);
946 old = btrfs_lock_root_node(root);
947 btrfs_cow_block(trans, root, old, NULL, 0, &old);
948 btrfs_set_lock_blocking(old);
950 btrfs_copy_root(trans, root, old, &tmp, objectid);
951 btrfs_tree_unlock(old);
952 free_extent_buffer(old);
954 /* see comments in should_cow_block() */
955 root->force_cow = 1;
956 smp_wmb();
958 btrfs_set_root_node(new_root_item, tmp);
959 /* record when the snapshot was created in key.offset */
960 key.offset = trans->transid;
961 ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
962 btrfs_tree_unlock(tmp);
963 free_extent_buffer(tmp);
964 BUG_ON(ret);
967 * insert root back/forward references
969 ret = btrfs_add_root_ref(trans, tree_root, objectid,
970 parent_root->root_key.objectid,
971 btrfs_ino(parent_inode), index,
972 dentry->d_name.name, dentry->d_name.len);
973 BUG_ON(ret);
974 dput(parent);
976 key.offset = (u64)-1;
977 pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
978 BUG_ON(IS_ERR(pending->snap));
980 btrfs_reloc_post_snapshot(trans, pending);
981 fail:
982 kfree(new_root_item);
983 trans->block_rsv = rsv;
984 btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
985 return 0;
989 * create all the snapshots we've scheduled for creation
991 static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
992 struct btrfs_fs_info *fs_info)
994 struct btrfs_pending_snapshot *pending;
995 struct list_head *head = &trans->transaction->pending_snapshots;
996 int ret;
998 list_for_each_entry(pending, head, list) {
999 ret = create_pending_snapshot(trans, fs_info, pending);
1000 BUG_ON(ret);
1002 return 0;
1005 static void update_super_roots(struct btrfs_root *root)
1007 struct btrfs_root_item *root_item;
1008 struct btrfs_super_block *super;
1010 super = root->fs_info->super_copy;
1012 root_item = &root->fs_info->chunk_root->root_item;
1013 super->chunk_root = root_item->bytenr;
1014 super->chunk_root_generation = root_item->generation;
1015 super->chunk_root_level = root_item->level;
1017 root_item = &root->fs_info->tree_root->root_item;
1018 super->root = root_item->bytenr;
1019 super->generation = root_item->generation;
1020 super->root_level = root_item->level;
1021 if (btrfs_test_opt(root, SPACE_CACHE))
1022 super->cache_generation = root_item->generation;
1025 int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
1027 int ret = 0;
1028 spin_lock(&info->trans_lock);
1029 if (info->running_transaction)
1030 ret = info->running_transaction->in_commit;
1031 spin_unlock(&info->trans_lock);
1032 return ret;
1035 int btrfs_transaction_blocked(struct btrfs_fs_info *info)
1037 int ret = 0;
1038 spin_lock(&info->trans_lock);
1039 if (info->running_transaction)
1040 ret = info->running_transaction->blocked;
1041 spin_unlock(&info->trans_lock);
1042 return ret;
1046 * wait for the current transaction commit to start and block subsequent
1047 * transaction joins
1049 static void wait_current_trans_commit_start(struct btrfs_root *root,
1050 struct btrfs_transaction *trans)
1052 wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit);
1056 * wait for the current transaction to start and then become unblocked.
1057 * caller holds ref.
1059 static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root,
1060 struct btrfs_transaction *trans)
1062 wait_event(root->fs_info->transaction_wait,
1063 trans->commit_done || (trans->in_commit && !trans->blocked));
1067 * commit transactions asynchronously. once btrfs_commit_transaction_async
1068 * returns, any subsequent transaction will not be allowed to join.
1070 struct btrfs_async_commit {
1071 struct btrfs_trans_handle *newtrans;
1072 struct btrfs_root *root;
1073 struct delayed_work work;
1076 static void do_async_commit(struct work_struct *work)
1078 struct btrfs_async_commit *ac =
1079 container_of(work, struct btrfs_async_commit, work.work);
1081 btrfs_commit_transaction(ac->newtrans, ac->root);
1082 kfree(ac);
1085 int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
1086 struct btrfs_root *root,
1087 int wait_for_unblock)
1089 struct btrfs_async_commit *ac;
1090 struct btrfs_transaction *cur_trans;
1092 ac = kmalloc(sizeof(*ac), GFP_NOFS);
1093 if (!ac)
1094 return -ENOMEM;
1096 INIT_DELAYED_WORK(&ac->work, do_async_commit);
1097 ac->root = root;
1098 ac->newtrans = btrfs_join_transaction(root);
1099 if (IS_ERR(ac->newtrans)) {
1100 int err = PTR_ERR(ac->newtrans);
1101 kfree(ac);
1102 return err;
1105 /* take transaction reference */
1106 cur_trans = trans->transaction;
1107 atomic_inc(&cur_trans->use_count);
1109 btrfs_end_transaction(trans, root);
1110 schedule_delayed_work(&ac->work, 0);
1112 /* wait for transaction to start and unblock */
1113 if (wait_for_unblock)
1114 wait_current_trans_commit_start_and_unblock(root, cur_trans);
1115 else
1116 wait_current_trans_commit_start(root, cur_trans);
1118 if (current->journal_info == trans)
1119 current->journal_info = NULL;
1121 put_transaction(cur_trans);
1122 return 0;
1126 * btrfs_transaction state sequence:
1127 * in_commit = 0, blocked = 0 (initial)
1128 * in_commit = 1, blocked = 1
1129 * blocked = 0
1130 * commit_done = 1
1132 int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
1133 struct btrfs_root *root)
1135 unsigned long joined = 0;
1136 struct btrfs_transaction *cur_trans;
1137 struct btrfs_transaction *prev_trans = NULL;
1138 DEFINE_WAIT(wait);
1139 int ret;
1140 int should_grow = 0;
1141 unsigned long now = get_seconds();
1142 int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
1144 btrfs_run_ordered_operations(root, 0);
1146 btrfs_trans_release_metadata(trans, root);
1147 trans->block_rsv = NULL;
1149 /* make a pass through all the delayed refs we have so far
1150 * any runnings procs may add more while we are here
1152 ret = btrfs_run_delayed_refs(trans, root, 0);
1153 BUG_ON(ret);
1155 cur_trans = trans->transaction;
1157 * set the flushing flag so procs in this transaction have to
1158 * start sending their work down.
1160 cur_trans->delayed_refs.flushing = 1;
1162 ret = btrfs_run_delayed_refs(trans, root, 0);
1163 BUG_ON(ret);
1165 spin_lock(&cur_trans->commit_lock);
1166 if (cur_trans->in_commit) {
1167 spin_unlock(&cur_trans->commit_lock);
1168 atomic_inc(&cur_trans->use_count);
1169 btrfs_end_transaction(trans, root);
1171 wait_for_commit(root, cur_trans);
1173 put_transaction(cur_trans);
1175 return 0;
1178 trans->transaction->in_commit = 1;
1179 trans->transaction->blocked = 1;
1180 spin_unlock(&cur_trans->commit_lock);
1181 wake_up(&root->fs_info->transaction_blocked_wait);
1183 spin_lock(&root->fs_info->trans_lock);
1184 if (cur_trans->list.prev != &root->fs_info->trans_list) {
1185 prev_trans = list_entry(cur_trans->list.prev,
1186 struct btrfs_transaction, list);
1187 if (!prev_trans->commit_done) {
1188 atomic_inc(&prev_trans->use_count);
1189 spin_unlock(&root->fs_info->trans_lock);
1191 wait_for_commit(root, prev_trans);
1193 put_transaction(prev_trans);
1194 } else {
1195 spin_unlock(&root->fs_info->trans_lock);
1197 } else {
1198 spin_unlock(&root->fs_info->trans_lock);
1201 if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
1202 should_grow = 1;
1204 do {
1205 int snap_pending = 0;
1207 joined = cur_trans->num_joined;
1208 if (!list_empty(&trans->transaction->pending_snapshots))
1209 snap_pending = 1;
1211 WARN_ON(cur_trans != trans->transaction);
1213 if (flush_on_commit || snap_pending) {
1214 btrfs_start_delalloc_inodes(root, 1);
1215 ret = btrfs_wait_ordered_extents(root, 0, 1);
1216 BUG_ON(ret);
1219 ret = btrfs_run_delayed_items(trans, root);
1220 BUG_ON(ret);
1223 * rename don't use btrfs_join_transaction, so, once we
1224 * set the transaction to blocked above, we aren't going
1225 * to get any new ordered operations. We can safely run
1226 * it here and no for sure that nothing new will be added
1227 * to the list
1229 btrfs_run_ordered_operations(root, 1);
1231 prepare_to_wait(&cur_trans->writer_wait, &wait,
1232 TASK_UNINTERRUPTIBLE);
1234 if (atomic_read(&cur_trans->num_writers) > 1)
1235 schedule_timeout(MAX_SCHEDULE_TIMEOUT);
1236 else if (should_grow)
1237 schedule_timeout(1);
1239 finish_wait(&cur_trans->writer_wait, &wait);
1240 } while (atomic_read(&cur_trans->num_writers) > 1 ||
1241 (should_grow && cur_trans->num_joined != joined));
1244 * Ok now we need to make sure to block out any other joins while we
1245 * commit the transaction. We could have started a join before setting
1246 * no_join so make sure to wait for num_writers to == 1 again.
1248 spin_lock(&root->fs_info->trans_lock);
1249 root->fs_info->trans_no_join = 1;
1250 spin_unlock(&root->fs_info->trans_lock);
1251 wait_event(cur_trans->writer_wait,
1252 atomic_read(&cur_trans->num_writers) == 1);
1255 * the reloc mutex makes sure that we stop
1256 * the balancing code from coming in and moving
1257 * extents around in the middle of the commit
1259 mutex_lock(&root->fs_info->reloc_mutex);
1261 ret = btrfs_run_delayed_items(trans, root);
1262 BUG_ON(ret);
1264 ret = create_pending_snapshots(trans, root->fs_info);
1265 BUG_ON(ret);
1267 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1268 BUG_ON(ret);
1271 * make sure none of the code above managed to slip in a
1272 * delayed item
1274 btrfs_assert_delayed_root_empty(root);
1276 WARN_ON(cur_trans != trans->transaction);
1278 btrfs_scrub_pause(root);
1279 /* btrfs_commit_tree_roots is responsible for getting the
1280 * various roots consistent with each other. Every pointer
1281 * in the tree of tree roots has to point to the most up to date
1282 * root for every subvolume and other tree. So, we have to keep
1283 * the tree logging code from jumping in and changing any
1284 * of the trees.
1286 * At this point in the commit, there can't be any tree-log
1287 * writers, but a little lower down we drop the trans mutex
1288 * and let new people in. By holding the tree_log_mutex
1289 * from now until after the super is written, we avoid races
1290 * with the tree-log code.
1292 mutex_lock(&root->fs_info->tree_log_mutex);
1294 ret = commit_fs_roots(trans, root);
1295 BUG_ON(ret);
1297 /* commit_fs_roots gets rid of all the tree log roots, it is now
1298 * safe to free the root of tree log roots
1300 btrfs_free_log_root_tree(trans, root->fs_info);
1302 ret = commit_cowonly_roots(trans, root);
1303 BUG_ON(ret);
1305 btrfs_prepare_extent_commit(trans, root);
1307 cur_trans = root->fs_info->running_transaction;
1309 btrfs_set_root_node(&root->fs_info->tree_root->root_item,
1310 root->fs_info->tree_root->node);
1311 switch_commit_root(root->fs_info->tree_root);
1313 btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
1314 root->fs_info->chunk_root->node);
1315 switch_commit_root(root->fs_info->chunk_root);
1317 update_super_roots(root);
1319 if (!root->fs_info->log_root_recovering) {
1320 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
1321 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
1324 memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
1325 sizeof(*root->fs_info->super_copy));
1327 trans->transaction->blocked = 0;
1328 spin_lock(&root->fs_info->trans_lock);
1329 root->fs_info->running_transaction = NULL;
1330 root->fs_info->trans_no_join = 0;
1331 spin_unlock(&root->fs_info->trans_lock);
1332 mutex_unlock(&root->fs_info->reloc_mutex);
1334 wake_up(&root->fs_info->transaction_wait);
1336 ret = btrfs_write_and_wait_transaction(trans, root);
1337 BUG_ON(ret);
1338 write_ctree_super(trans, root, 0);
1341 * the super is written, we can safely allow the tree-loggers
1342 * to go about their business
1344 mutex_unlock(&root->fs_info->tree_log_mutex);
1346 btrfs_finish_extent_commit(trans, root);
1348 cur_trans->commit_done = 1;
1350 root->fs_info->last_trans_committed = cur_trans->transid;
1352 wake_up(&cur_trans->commit_wait);
1354 spin_lock(&root->fs_info->trans_lock);
1355 list_del_init(&cur_trans->list);
1356 spin_unlock(&root->fs_info->trans_lock);
1358 put_transaction(cur_trans);
1359 put_transaction(cur_trans);
1361 trace_btrfs_transaction_commit(root);
1363 btrfs_scrub_continue(root);
1365 if (current->journal_info == trans)
1366 current->journal_info = NULL;
1368 kmem_cache_free(btrfs_trans_handle_cachep, trans);
1370 if (current != root->fs_info->transaction_kthread)
1371 btrfs_run_delayed_iputs(root);
1373 return ret;
1377 * interface function to delete all the snapshots we have scheduled for deletion
1379 int btrfs_clean_old_snapshots(struct btrfs_root *root)
1381 LIST_HEAD(list);
1382 struct btrfs_fs_info *fs_info = root->fs_info;
1384 spin_lock(&fs_info->trans_lock);
1385 list_splice_init(&fs_info->dead_roots, &list);
1386 spin_unlock(&fs_info->trans_lock);
1388 while (!list_empty(&list)) {
1389 root = list_entry(list.next, struct btrfs_root, root_list);
1390 list_del(&root->root_list);
1392 btrfs_kill_all_delayed_nodes(root);
1394 if (btrfs_header_backref_rev(root->node) <
1395 BTRFS_MIXED_BACKREF_REV)
1396 btrfs_drop_snapshot(root, NULL, 0);
1397 else
1398 btrfs_drop_snapshot(root, NULL, 1);
1400 return 0;