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.
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>
27 #include "transaction.h"
30 #include "inode-map.h"
32 #define BTRFS_ROOT_TRANS_TAG 0
34 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 WARN_ON(transaction->delayed_refs.root.rb_node);
40 WARN_ON(!list_empty(&transaction->delayed_refs.seq_head));
41 memset(transaction, 0, sizeof(*transaction));
42 kmem_cache_free(btrfs_transaction_cachep, transaction);
46 static noinline void switch_commit_root(struct btrfs_root *root)
48 free_extent_buffer(root->commit_root);
49 root->commit_root = btrfs_root_node(root);
53 * either allocate a new transaction or hop into the existing one
55 static noinline int join_transaction(struct btrfs_root *root, int nofail)
57 struct btrfs_transaction *cur_trans;
59 spin_lock(&root->fs_info->trans_lock);
61 /* The file system has been taken offline. No new transactions. */
62 if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
63 spin_unlock(&root->fs_info->trans_lock);
67 if (root->fs_info->trans_no_join) {
69 spin_unlock(&root->fs_info->trans_lock);
74 cur_trans = root->fs_info->running_transaction;
76 if (cur_trans->aborted)
77 return cur_trans->aborted;
78 atomic_inc(&cur_trans->use_count);
79 atomic_inc(&cur_trans->num_writers);
80 cur_trans->num_joined++;
81 spin_unlock(&root->fs_info->trans_lock);
84 spin_unlock(&root->fs_info->trans_lock);
86 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
90 spin_lock(&root->fs_info->trans_lock);
91 if (root->fs_info->running_transaction) {
93 * someone started a transaction after we unlocked. Make sure
94 * to redo the trans_no_join checks above
96 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
97 cur_trans = root->fs_info->running_transaction;
101 atomic_set(&cur_trans->num_writers, 1);
102 cur_trans->num_joined = 0;
103 init_waitqueue_head(&cur_trans->writer_wait);
104 init_waitqueue_head(&cur_trans->commit_wait);
105 cur_trans->in_commit = 0;
106 cur_trans->blocked = 0;
108 * One for this trans handle, one so it will live on until we
109 * commit the transaction.
111 atomic_set(&cur_trans->use_count, 2);
112 cur_trans->commit_done = 0;
113 cur_trans->start_time = get_seconds();
115 cur_trans->delayed_refs.root = RB_ROOT;
116 cur_trans->delayed_refs.num_entries = 0;
117 cur_trans->delayed_refs.num_heads_ready = 0;
118 cur_trans->delayed_refs.num_heads = 0;
119 cur_trans->delayed_refs.flushing = 0;
120 cur_trans->delayed_refs.run_delayed_start = 0;
121 cur_trans->delayed_refs.seq = 1;
122 init_waitqueue_head(&cur_trans->delayed_refs.seq_wait);
123 spin_lock_init(&cur_trans->commit_lock);
124 spin_lock_init(&cur_trans->delayed_refs.lock);
125 INIT_LIST_HEAD(&cur_trans->delayed_refs.seq_head);
127 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
128 list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
129 extent_io_tree_init(&cur_trans->dirty_pages,
130 root->fs_info->btree_inode->i_mapping);
131 root->fs_info->generation++;
132 cur_trans->transid = root->fs_info->generation;
133 root->fs_info->running_transaction = cur_trans;
134 cur_trans->aborted = 0;
135 spin_unlock(&root->fs_info->trans_lock);
141 * this does all the record keeping required to make sure that a reference
142 * counted root is properly recorded in a given transaction. This is required
143 * to make sure the old root from before we joined the transaction is deleted
144 * when the transaction commits
146 static int record_root_in_trans(struct btrfs_trans_handle *trans,
147 struct btrfs_root *root)
149 if (root->ref_cows && root->last_trans < trans->transid) {
150 WARN_ON(root == root->fs_info->extent_root);
151 WARN_ON(root->commit_root != root->node);
154 * see below for in_trans_setup usage rules
155 * we have the reloc mutex held now, so there
156 * is only one writer in this function
158 root->in_trans_setup = 1;
160 /* make sure readers find in_trans_setup before
161 * they find our root->last_trans update
165 spin_lock(&root->fs_info->fs_roots_radix_lock);
166 if (root->last_trans == trans->transid) {
167 spin_unlock(&root->fs_info->fs_roots_radix_lock);
170 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
171 (unsigned long)root->root_key.objectid,
172 BTRFS_ROOT_TRANS_TAG);
173 spin_unlock(&root->fs_info->fs_roots_radix_lock);
174 root->last_trans = trans->transid;
176 /* this is pretty tricky. We don't want to
177 * take the relocation lock in btrfs_record_root_in_trans
178 * unless we're really doing the first setup for this root in
181 * Normally we'd use root->last_trans as a flag to decide
182 * if we want to take the expensive mutex.
184 * But, we have to set root->last_trans before we
185 * init the relocation root, otherwise, we trip over warnings
186 * in ctree.c. The solution used here is to flag ourselves
187 * with root->in_trans_setup. When this is 1, we're still
188 * fixing up the reloc trees and everyone must wait.
190 * When this is zero, they can trust root->last_trans and fly
191 * through btrfs_record_root_in_trans without having to take the
192 * lock. smp_wmb() makes sure that all the writes above are
193 * done before we pop in the zero below
195 btrfs_init_reloc_root(trans, root);
197 root->in_trans_setup = 0;
203 int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
204 struct btrfs_root *root)
210 * see record_root_in_trans for comments about in_trans_setup usage
214 if (root->last_trans == trans->transid &&
215 !root->in_trans_setup)
218 mutex_lock(&root->fs_info->reloc_mutex);
219 record_root_in_trans(trans, root);
220 mutex_unlock(&root->fs_info->reloc_mutex);
225 /* wait for commit against the current transaction to become unblocked
226 * when this is done, it is safe to start a new transaction, but the current
227 * transaction might not be fully on disk.
229 static void wait_current_trans(struct btrfs_root *root)
231 struct btrfs_transaction *cur_trans;
233 spin_lock(&root->fs_info->trans_lock);
234 cur_trans = root->fs_info->running_transaction;
235 if (cur_trans && cur_trans->blocked) {
236 atomic_inc(&cur_trans->use_count);
237 spin_unlock(&root->fs_info->trans_lock);
239 wait_event(root->fs_info->transaction_wait,
240 !cur_trans->blocked);
241 put_transaction(cur_trans);
243 spin_unlock(&root->fs_info->trans_lock);
247 enum btrfs_trans_type {
254 static int may_wait_transaction(struct btrfs_root *root, int type)
256 if (root->fs_info->log_root_recovering)
259 if (type == TRANS_USERSPACE)
262 if (type == TRANS_START &&
263 !atomic_read(&root->fs_info->open_ioctl_trans))
269 static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
270 u64 num_items, int type)
272 struct btrfs_trans_handle *h;
273 struct btrfs_transaction *cur_trans;
277 if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
278 return ERR_PTR(-EROFS);
280 if (current->journal_info) {
281 WARN_ON(type != TRANS_JOIN && type != TRANS_JOIN_NOLOCK);
282 h = current->journal_info;
284 h->orig_rsv = h->block_rsv;
290 * Do the reservation before we join the transaction so we can do all
291 * the appropriate flushing if need be.
293 if (num_items > 0 && root != root->fs_info->chunk_root) {
294 num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
295 ret = btrfs_block_rsv_add(root,
296 &root->fs_info->trans_block_rsv,
302 h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
304 return ERR_PTR(-ENOMEM);
306 if (may_wait_transaction(root, type))
307 wait_current_trans(root);
310 ret = join_transaction(root, type == TRANS_JOIN_NOLOCK);
312 wait_current_trans(root);
313 } while (ret == -EBUSY);
316 kmem_cache_free(btrfs_trans_handle_cachep, h);
320 cur_trans = root->fs_info->running_transaction;
322 h->transid = cur_trans->transid;
323 h->transaction = cur_trans;
325 h->bytes_reserved = 0;
326 h->delayed_ref_updates = 0;
333 if (cur_trans->blocked && may_wait_transaction(root, type)) {
334 btrfs_commit_transaction(h, root);
339 trace_btrfs_space_reservation(root->fs_info, "transaction",
340 h->transid, num_bytes, 1);
341 h->block_rsv = &root->fs_info->trans_block_rsv;
342 h->bytes_reserved = num_bytes;
346 btrfs_record_root_in_trans(h, root);
348 if (!current->journal_info && type != TRANS_USERSPACE)
349 current->journal_info = h;
353 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
356 return start_transaction(root, num_items, TRANS_START);
358 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
360 return start_transaction(root, 0, TRANS_JOIN);
363 struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
365 return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
368 struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
370 return start_transaction(root, 0, TRANS_USERSPACE);
373 /* wait for a transaction commit to be fully complete */
374 static noinline void wait_for_commit(struct btrfs_root *root,
375 struct btrfs_transaction *commit)
377 wait_event(commit->commit_wait, commit->commit_done);
380 int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
382 struct btrfs_transaction *cur_trans = NULL, *t;
387 if (transid <= root->fs_info->last_trans_committed)
390 /* find specified transaction */
391 spin_lock(&root->fs_info->trans_lock);
392 list_for_each_entry(t, &root->fs_info->trans_list, list) {
393 if (t->transid == transid) {
395 atomic_inc(&cur_trans->use_count);
398 if (t->transid > transid)
401 spin_unlock(&root->fs_info->trans_lock);
404 goto out; /* bad transid */
406 /* find newest transaction that is committing | committed */
407 spin_lock(&root->fs_info->trans_lock);
408 list_for_each_entry_reverse(t, &root->fs_info->trans_list,
414 atomic_inc(&cur_trans->use_count);
418 spin_unlock(&root->fs_info->trans_lock);
420 goto out; /* nothing committing|committed */
423 wait_for_commit(root, cur_trans);
425 put_transaction(cur_trans);
431 void btrfs_throttle(struct btrfs_root *root)
433 if (!atomic_read(&root->fs_info->open_ioctl_trans))
434 wait_current_trans(root);
437 static int should_end_transaction(struct btrfs_trans_handle *trans,
438 struct btrfs_root *root)
442 ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
446 int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
447 struct btrfs_root *root)
449 struct btrfs_transaction *cur_trans = trans->transaction;
450 struct btrfs_block_rsv *rsv = trans->block_rsv;
455 if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
459 * We need to do this in case we're deleting csums so the global block
460 * rsv get's used instead of the csum block rsv.
462 trans->block_rsv = NULL;
464 updates = trans->delayed_ref_updates;
465 trans->delayed_ref_updates = 0;
467 err = btrfs_run_delayed_refs(trans, root, updates);
468 if (err) /* Error code will also eval true */
472 trans->block_rsv = rsv;
474 return should_end_transaction(trans, root);
477 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
478 struct btrfs_root *root, int throttle, int lock)
480 struct btrfs_transaction *cur_trans = trans->transaction;
481 struct btrfs_fs_info *info = root->fs_info;
484 if (--trans->use_count) {
485 trans->block_rsv = trans->orig_rsv;
489 btrfs_trans_release_metadata(trans, root);
490 trans->block_rsv = NULL;
492 unsigned long cur = trans->delayed_ref_updates;
493 trans->delayed_ref_updates = 0;
495 trans->transaction->delayed_refs.num_heads_ready > 64) {
496 trans->delayed_ref_updates = 0;
497 btrfs_run_delayed_refs(trans, root, cur);
504 if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
505 should_end_transaction(trans, root)) {
506 trans->transaction->blocked = 1;
510 if (lock && cur_trans->blocked && !cur_trans->in_commit) {
513 * We may race with somebody else here so end up having
514 * to call end_transaction on ourselves again, so inc
518 return btrfs_commit_transaction(trans, root);
520 wake_up_process(info->transaction_kthread);
524 WARN_ON(cur_trans != info->running_transaction);
525 WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
526 atomic_dec(&cur_trans->num_writers);
529 if (waitqueue_active(&cur_trans->writer_wait))
530 wake_up(&cur_trans->writer_wait);
531 put_transaction(cur_trans);
533 if (current->journal_info == trans)
534 current->journal_info = NULL;
535 memset(trans, 0, sizeof(*trans));
536 kmem_cache_free(btrfs_trans_handle_cachep, trans);
539 btrfs_run_delayed_iputs(root);
541 if (trans->aborted ||
542 root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
549 int btrfs_end_transaction(struct btrfs_trans_handle *trans,
550 struct btrfs_root *root)
554 ret = __btrfs_end_transaction(trans, root, 0, 1);
560 int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
561 struct btrfs_root *root)
565 ret = __btrfs_end_transaction(trans, root, 1, 1);
571 int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
572 struct btrfs_root *root)
576 ret = __btrfs_end_transaction(trans, root, 0, 0);
582 int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans,
583 struct btrfs_root *root)
585 return __btrfs_end_transaction(trans, root, 1, 1);
589 * when btree blocks are allocated, they have some corresponding bits set for
590 * them in one of two extent_io trees. This is used to make sure all of
591 * those extents are sent to disk but does not wait on them
593 int btrfs_write_marked_extents(struct btrfs_root *root,
594 struct extent_io_tree *dirty_pages, int mark)
598 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
602 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
604 convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT, mark,
606 err = filemap_fdatawrite_range(mapping, start, end);
618 * when btree blocks are allocated, they have some corresponding bits set for
619 * them in one of two extent_io trees. This is used to make sure all of
620 * those extents are on disk for transaction or log commit. We wait
621 * on all the pages and clear them from the dirty pages state tree
623 int btrfs_wait_marked_extents(struct btrfs_root *root,
624 struct extent_io_tree *dirty_pages, int mark)
628 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
632 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
634 clear_extent_bits(dirty_pages, start, end, EXTENT_NEED_WAIT, GFP_NOFS);
635 err = filemap_fdatawait_range(mapping, start, end);
647 * when btree blocks are allocated, they have some corresponding bits set for
648 * them in one of two extent_io trees. This is used to make sure all of
649 * those extents are on disk for transaction or log commit
651 int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
652 struct extent_io_tree *dirty_pages, int mark)
657 ret = btrfs_write_marked_extents(root, dirty_pages, mark);
658 ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
667 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
668 struct btrfs_root *root)
670 if (!trans || !trans->transaction) {
671 struct inode *btree_inode;
672 btree_inode = root->fs_info->btree_inode;
673 return filemap_write_and_wait(btree_inode->i_mapping);
675 return btrfs_write_and_wait_marked_extents(root,
676 &trans->transaction->dirty_pages,
681 * this is used to update the root pointer in the tree of tree roots.
683 * But, in the case of the extent allocation tree, updating the root
684 * pointer may allocate blocks which may change the root of the extent
687 * So, this loops and repeats and makes sure the cowonly root didn't
688 * change while the root pointer was being updated in the metadata.
690 static int update_cowonly_root(struct btrfs_trans_handle *trans,
691 struct btrfs_root *root)
696 struct btrfs_root *tree_root = root->fs_info->tree_root;
698 old_root_used = btrfs_root_used(&root->root_item);
699 btrfs_write_dirty_block_groups(trans, root);
702 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
703 if (old_root_bytenr == root->node->start &&
704 old_root_used == btrfs_root_used(&root->root_item))
707 btrfs_set_root_node(&root->root_item, root->node);
708 ret = btrfs_update_root(trans, tree_root,
714 old_root_used = btrfs_root_used(&root->root_item);
715 ret = btrfs_write_dirty_block_groups(trans, root);
720 if (root != root->fs_info->extent_root)
721 switch_commit_root(root);
727 * update all the cowonly tree roots on disk
729 * The error handling in this function may not be obvious. Any of the
730 * failures will cause the file system to go offline. We still need
731 * to clean up the delayed refs.
733 static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
734 struct btrfs_root *root)
736 struct btrfs_fs_info *fs_info = root->fs_info;
737 struct list_head *next;
738 struct extent_buffer *eb;
741 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
745 eb = btrfs_lock_root_node(fs_info->tree_root);
746 ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,
748 btrfs_tree_unlock(eb);
749 free_extent_buffer(eb);
754 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
758 while (!list_empty(&fs_info->dirty_cowonly_roots)) {
759 next = fs_info->dirty_cowonly_roots.next;
761 root = list_entry(next, struct btrfs_root, dirty_list);
763 ret = update_cowonly_root(trans, root);
768 down_write(&fs_info->extent_commit_sem);
769 switch_commit_root(fs_info->extent_root);
770 up_write(&fs_info->extent_commit_sem);
776 * dead roots are old snapshots that need to be deleted. This allocates
777 * a dirty root struct and adds it into the list of dead roots that need to
780 int btrfs_add_dead_root(struct btrfs_root *root)
782 spin_lock(&root->fs_info->trans_lock);
783 list_add(&root->root_list, &root->fs_info->dead_roots);
784 spin_unlock(&root->fs_info->trans_lock);
789 * update all the cowonly tree roots on disk
791 static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
792 struct btrfs_root *root)
794 struct btrfs_root *gang[8];
795 struct btrfs_fs_info *fs_info = root->fs_info;
800 spin_lock(&fs_info->fs_roots_radix_lock);
802 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
805 BTRFS_ROOT_TRANS_TAG);
808 for (i = 0; i < ret; i++) {
810 radix_tree_tag_clear(&fs_info->fs_roots_radix,
811 (unsigned long)root->root_key.objectid,
812 BTRFS_ROOT_TRANS_TAG);
813 spin_unlock(&fs_info->fs_roots_radix_lock);
815 btrfs_free_log(trans, root);
816 btrfs_update_reloc_root(trans, root);
817 btrfs_orphan_commit_root(trans, root);
819 btrfs_save_ino_cache(root, trans);
821 /* see comments in should_cow_block() */
825 if (root->commit_root != root->node) {
826 mutex_lock(&root->fs_commit_mutex);
827 switch_commit_root(root);
828 btrfs_unpin_free_ino(root);
829 mutex_unlock(&root->fs_commit_mutex);
831 btrfs_set_root_node(&root->root_item,
835 err = btrfs_update_root(trans, fs_info->tree_root,
838 spin_lock(&fs_info->fs_roots_radix_lock);
843 spin_unlock(&fs_info->fs_roots_radix_lock);
848 * defrag a given btree. If cacheonly == 1, this won't read from the disk,
849 * otherwise every leaf in the btree is read and defragged.
851 int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
853 struct btrfs_fs_info *info = root->fs_info;
854 struct btrfs_trans_handle *trans;
858 if (xchg(&root->defrag_running, 1))
862 trans = btrfs_start_transaction(root, 0);
864 return PTR_ERR(trans);
866 ret = btrfs_defrag_leaves(trans, root, cacheonly);
868 nr = trans->blocks_used;
869 btrfs_end_transaction(trans, root);
870 btrfs_btree_balance_dirty(info->tree_root, nr);
873 if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
876 root->defrag_running = 0;
881 * new snapshots need to be created at a very specific time in the
882 * transaction commit. This does the actual creation
884 static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
885 struct btrfs_fs_info *fs_info,
886 struct btrfs_pending_snapshot *pending)
888 struct btrfs_key key;
889 struct btrfs_root_item *new_root_item;
890 struct btrfs_root *tree_root = fs_info->tree_root;
891 struct btrfs_root *root = pending->root;
892 struct btrfs_root *parent_root;
893 struct btrfs_block_rsv *rsv;
894 struct inode *parent_inode;
895 struct dentry *parent;
896 struct dentry *dentry;
897 struct extent_buffer *tmp;
898 struct extent_buffer *old;
905 rsv = trans->block_rsv;
907 new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
908 if (!new_root_item) {
909 ret = pending->error = -ENOMEM;
913 ret = btrfs_find_free_objectid(tree_root, &objectid);
915 pending->error = ret;
919 btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
921 if (to_reserve > 0) {
922 ret = btrfs_block_rsv_add_noflush(root, &pending->block_rsv,
925 pending->error = ret;
930 key.objectid = objectid;
931 key.offset = (u64)-1;
932 key.type = BTRFS_ROOT_ITEM_KEY;
934 trans->block_rsv = &pending->block_rsv;
936 dentry = pending->dentry;
937 parent = dget_parent(dentry);
938 parent_inode = parent->d_inode;
939 parent_root = BTRFS_I(parent_inode)->root;
940 record_root_in_trans(trans, parent_root);
943 * insert the directory item
945 ret = btrfs_set_inode_index(parent_inode, &index);
946 BUG_ON(ret); /* -ENOMEM */
947 ret = btrfs_insert_dir_item(trans, parent_root,
948 dentry->d_name.name, dentry->d_name.len,
950 BTRFS_FT_DIR, index);
951 if (ret == -EEXIST) {
952 pending->error = -EEXIST;
956 goto abort_trans_dput;
959 btrfs_i_size_write(parent_inode, parent_inode->i_size +
960 dentry->d_name.len * 2);
961 ret = btrfs_update_inode(trans, parent_root, parent_inode);
963 goto abort_trans_dput;
966 * pull in the delayed directory update
967 * and the delayed inode item
968 * otherwise we corrupt the FS during
971 ret = btrfs_run_delayed_items(trans, root);
972 if (ret) { /* Transaction aborted */
977 record_root_in_trans(trans, root);
978 btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
979 memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
980 btrfs_check_and_init_root_item(new_root_item);
982 root_flags = btrfs_root_flags(new_root_item);
983 if (pending->readonly)
984 root_flags |= BTRFS_ROOT_SUBVOL_RDONLY;
986 root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY;
987 btrfs_set_root_flags(new_root_item, root_flags);
989 old = btrfs_lock_root_node(root);
990 ret = btrfs_cow_block(trans, root, old, NULL, 0, &old);
992 btrfs_tree_unlock(old);
993 free_extent_buffer(old);
994 goto abort_trans_dput;
997 btrfs_set_lock_blocking(old);
999 ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
1000 /* clean up in any case */
1001 btrfs_tree_unlock(old);
1002 free_extent_buffer(old);
1004 goto abort_trans_dput;
1006 /* see comments in should_cow_block() */
1007 root->force_cow = 1;
1010 btrfs_set_root_node(new_root_item, tmp);
1011 /* record when the snapshot was created in key.offset */
1012 key.offset = trans->transid;
1013 ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
1014 btrfs_tree_unlock(tmp);
1015 free_extent_buffer(tmp);
1017 goto abort_trans_dput;
1020 * insert root back/forward references
1022 ret = btrfs_add_root_ref(trans, tree_root, objectid,
1023 parent_root->root_key.objectid,
1024 btrfs_ino(parent_inode), index,
1025 dentry->d_name.name, dentry->d_name.len);
1030 key.offset = (u64)-1;
1031 pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
1032 if (IS_ERR(pending->snap)) {
1033 ret = PTR_ERR(pending->snap);
1037 ret = btrfs_reloc_post_snapshot(trans, pending);
1042 kfree(new_root_item);
1043 trans->block_rsv = rsv;
1044 btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
1050 btrfs_abort_transaction(trans, root, ret);
1055 * create all the snapshots we've scheduled for creation
1057 static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
1058 struct btrfs_fs_info *fs_info)
1060 struct btrfs_pending_snapshot *pending;
1061 struct list_head *head = &trans->transaction->pending_snapshots;
1063 list_for_each_entry(pending, head, list)
1064 create_pending_snapshot(trans, fs_info, pending);
1068 static void update_super_roots(struct btrfs_root *root)
1070 struct btrfs_root_item *root_item;
1071 struct btrfs_super_block *super;
1073 super = root->fs_info->super_copy;
1075 root_item = &root->fs_info->chunk_root->root_item;
1076 super->chunk_root = root_item->bytenr;
1077 super->chunk_root_generation = root_item->generation;
1078 super->chunk_root_level = root_item->level;
1080 root_item = &root->fs_info->tree_root->root_item;
1081 super->root = root_item->bytenr;
1082 super->generation = root_item->generation;
1083 super->root_level = root_item->level;
1084 if (btrfs_test_opt(root, SPACE_CACHE))
1085 super->cache_generation = root_item->generation;
1088 int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
1091 spin_lock(&info->trans_lock);
1092 if (info->running_transaction)
1093 ret = info->running_transaction->in_commit;
1094 spin_unlock(&info->trans_lock);
1098 int btrfs_transaction_blocked(struct btrfs_fs_info *info)
1101 spin_lock(&info->trans_lock);
1102 if (info->running_transaction)
1103 ret = info->running_transaction->blocked;
1104 spin_unlock(&info->trans_lock);
1109 * wait for the current transaction commit to start and block subsequent
1112 static void wait_current_trans_commit_start(struct btrfs_root *root,
1113 struct btrfs_transaction *trans)
1115 wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit);
1119 * wait for the current transaction to start and then become unblocked.
1122 static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root,
1123 struct btrfs_transaction *trans)
1125 wait_event(root->fs_info->transaction_wait,
1126 trans->commit_done || (trans->in_commit && !trans->blocked));
1130 * commit transactions asynchronously. once btrfs_commit_transaction_async
1131 * returns, any subsequent transaction will not be allowed to join.
1133 struct btrfs_async_commit {
1134 struct btrfs_trans_handle *newtrans;
1135 struct btrfs_root *root;
1136 struct delayed_work work;
1139 static void do_async_commit(struct work_struct *work)
1141 struct btrfs_async_commit *ac =
1142 container_of(work, struct btrfs_async_commit, work.work);
1144 btrfs_commit_transaction(ac->newtrans, ac->root);
1148 int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
1149 struct btrfs_root *root,
1150 int wait_for_unblock)
1152 struct btrfs_async_commit *ac;
1153 struct btrfs_transaction *cur_trans;
1155 ac = kmalloc(sizeof(*ac), GFP_NOFS);
1159 INIT_DELAYED_WORK(&ac->work, do_async_commit);
1161 ac->newtrans = btrfs_join_transaction(root);
1162 if (IS_ERR(ac->newtrans)) {
1163 int err = PTR_ERR(ac->newtrans);
1168 /* take transaction reference */
1169 cur_trans = trans->transaction;
1170 atomic_inc(&cur_trans->use_count);
1172 btrfs_end_transaction(trans, root);
1173 schedule_delayed_work(&ac->work, 0);
1175 /* wait for transaction to start and unblock */
1176 if (wait_for_unblock)
1177 wait_current_trans_commit_start_and_unblock(root, cur_trans);
1179 wait_current_trans_commit_start(root, cur_trans);
1181 if (current->journal_info == trans)
1182 current->journal_info = NULL;
1184 put_transaction(cur_trans);
1189 static void cleanup_transaction(struct btrfs_trans_handle *trans,
1190 struct btrfs_root *root)
1192 struct btrfs_transaction *cur_trans = trans->transaction;
1194 WARN_ON(trans->use_count > 1);
1196 spin_lock(&root->fs_info->trans_lock);
1197 list_del_init(&cur_trans->list);
1198 spin_unlock(&root->fs_info->trans_lock);
1200 btrfs_cleanup_one_transaction(trans->transaction, root);
1202 put_transaction(cur_trans);
1203 put_transaction(cur_trans);
1205 trace_btrfs_transaction_commit(root);
1207 btrfs_scrub_continue(root);
1209 if (current->journal_info == trans)
1210 current->journal_info = NULL;
1212 kmem_cache_free(btrfs_trans_handle_cachep, trans);
1216 * btrfs_transaction state sequence:
1217 * in_commit = 0, blocked = 0 (initial)
1218 * in_commit = 1, blocked = 1
1222 int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
1223 struct btrfs_root *root)
1225 unsigned long joined = 0;
1226 struct btrfs_transaction *cur_trans = trans->transaction;
1227 struct btrfs_transaction *prev_trans = NULL;
1230 int should_grow = 0;
1231 unsigned long now = get_seconds();
1232 int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
1234 btrfs_run_ordered_operations(root, 0);
1236 btrfs_trans_release_metadata(trans, root);
1237 trans->block_rsv = NULL;
1239 if (cur_trans->aborted)
1240 goto cleanup_transaction;
1242 /* make a pass through all the delayed refs we have so far
1243 * any runnings procs may add more while we are here
1245 ret = btrfs_run_delayed_refs(trans, root, 0);
1247 goto cleanup_transaction;
1249 cur_trans = trans->transaction;
1252 * set the flushing flag so procs in this transaction have to
1253 * start sending their work down.
1255 cur_trans->delayed_refs.flushing = 1;
1257 ret = btrfs_run_delayed_refs(trans, root, 0);
1259 goto cleanup_transaction;
1261 spin_lock(&cur_trans->commit_lock);
1262 if (cur_trans->in_commit) {
1263 spin_unlock(&cur_trans->commit_lock);
1264 atomic_inc(&cur_trans->use_count);
1265 ret = btrfs_end_transaction(trans, root);
1267 wait_for_commit(root, cur_trans);
1269 put_transaction(cur_trans);
1274 trans->transaction->in_commit = 1;
1275 trans->transaction->blocked = 1;
1276 spin_unlock(&cur_trans->commit_lock);
1277 wake_up(&root->fs_info->transaction_blocked_wait);
1279 spin_lock(&root->fs_info->trans_lock);
1280 if (cur_trans->list.prev != &root->fs_info->trans_list) {
1281 prev_trans = list_entry(cur_trans->list.prev,
1282 struct btrfs_transaction, list);
1283 if (!prev_trans->commit_done) {
1284 atomic_inc(&prev_trans->use_count);
1285 spin_unlock(&root->fs_info->trans_lock);
1287 wait_for_commit(root, prev_trans);
1289 put_transaction(prev_trans);
1291 spin_unlock(&root->fs_info->trans_lock);
1294 spin_unlock(&root->fs_info->trans_lock);
1297 if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
1301 int snap_pending = 0;
1303 joined = cur_trans->num_joined;
1304 if (!list_empty(&trans->transaction->pending_snapshots))
1307 WARN_ON(cur_trans != trans->transaction);
1309 if (flush_on_commit || snap_pending) {
1310 btrfs_start_delalloc_inodes(root, 1);
1311 btrfs_wait_ordered_extents(root, 0, 1);
1314 ret = btrfs_run_delayed_items(trans, root);
1316 goto cleanup_transaction;
1319 * rename don't use btrfs_join_transaction, so, once we
1320 * set the transaction to blocked above, we aren't going
1321 * to get any new ordered operations. We can safely run
1322 * it here and no for sure that nothing new will be added
1325 btrfs_run_ordered_operations(root, 1);
1327 prepare_to_wait(&cur_trans->writer_wait, &wait,
1328 TASK_UNINTERRUPTIBLE);
1330 if (atomic_read(&cur_trans->num_writers) > 1)
1331 schedule_timeout(MAX_SCHEDULE_TIMEOUT);
1332 else if (should_grow)
1333 schedule_timeout(1);
1335 finish_wait(&cur_trans->writer_wait, &wait);
1336 } while (atomic_read(&cur_trans->num_writers) > 1 ||
1337 (should_grow && cur_trans->num_joined != joined));
1340 * Ok now we need to make sure to block out any other joins while we
1341 * commit the transaction. We could have started a join before setting
1342 * no_join so make sure to wait for num_writers to == 1 again.
1344 spin_lock(&root->fs_info->trans_lock);
1345 root->fs_info->trans_no_join = 1;
1346 spin_unlock(&root->fs_info->trans_lock);
1347 wait_event(cur_trans->writer_wait,
1348 atomic_read(&cur_trans->num_writers) == 1);
1351 * the reloc mutex makes sure that we stop
1352 * the balancing code from coming in and moving
1353 * extents around in the middle of the commit
1355 mutex_lock(&root->fs_info->reloc_mutex);
1357 ret = btrfs_run_delayed_items(trans, root);
1359 mutex_unlock(&root->fs_info->reloc_mutex);
1360 goto cleanup_transaction;
1363 ret = create_pending_snapshots(trans, root->fs_info);
1365 mutex_unlock(&root->fs_info->reloc_mutex);
1366 goto cleanup_transaction;
1369 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1371 mutex_unlock(&root->fs_info->reloc_mutex);
1372 goto cleanup_transaction;
1376 * make sure none of the code above managed to slip in a
1379 btrfs_assert_delayed_root_empty(root);
1381 WARN_ON(cur_trans != trans->transaction);
1383 btrfs_scrub_pause(root);
1384 /* btrfs_commit_tree_roots is responsible for getting the
1385 * various roots consistent with each other. Every pointer
1386 * in the tree of tree roots has to point to the most up to date
1387 * root for every subvolume and other tree. So, we have to keep
1388 * the tree logging code from jumping in and changing any
1391 * At this point in the commit, there can't be any tree-log
1392 * writers, but a little lower down we drop the trans mutex
1393 * and let new people in. By holding the tree_log_mutex
1394 * from now until after the super is written, we avoid races
1395 * with the tree-log code.
1397 mutex_lock(&root->fs_info->tree_log_mutex);
1399 ret = commit_fs_roots(trans, root);
1401 mutex_unlock(&root->fs_info->tree_log_mutex);
1402 goto cleanup_transaction;
1405 /* commit_fs_roots gets rid of all the tree log roots, it is now
1406 * safe to free the root of tree log roots
1408 btrfs_free_log_root_tree(trans, root->fs_info);
1410 ret = commit_cowonly_roots(trans, root);
1412 mutex_unlock(&root->fs_info->tree_log_mutex);
1413 goto cleanup_transaction;
1416 btrfs_prepare_extent_commit(trans, root);
1418 cur_trans = root->fs_info->running_transaction;
1420 btrfs_set_root_node(&root->fs_info->tree_root->root_item,
1421 root->fs_info->tree_root->node);
1422 switch_commit_root(root->fs_info->tree_root);
1424 btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
1425 root->fs_info->chunk_root->node);
1426 switch_commit_root(root->fs_info->chunk_root);
1428 update_super_roots(root);
1430 if (!root->fs_info->log_root_recovering) {
1431 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
1432 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
1435 memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
1436 sizeof(*root->fs_info->super_copy));
1438 trans->transaction->blocked = 0;
1439 spin_lock(&root->fs_info->trans_lock);
1440 root->fs_info->running_transaction = NULL;
1441 root->fs_info->trans_no_join = 0;
1442 spin_unlock(&root->fs_info->trans_lock);
1443 mutex_unlock(&root->fs_info->reloc_mutex);
1445 wake_up(&root->fs_info->transaction_wait);
1447 ret = btrfs_write_and_wait_transaction(trans, root);
1449 btrfs_error(root->fs_info, ret,
1450 "Error while writing out transaction.");
1451 mutex_unlock(&root->fs_info->tree_log_mutex);
1452 goto cleanup_transaction;
1455 ret = write_ctree_super(trans, root, 0);
1457 mutex_unlock(&root->fs_info->tree_log_mutex);
1458 goto cleanup_transaction;
1462 * the super is written, we can safely allow the tree-loggers
1463 * to go about their business
1465 mutex_unlock(&root->fs_info->tree_log_mutex);
1467 btrfs_finish_extent_commit(trans, root);
1469 cur_trans->commit_done = 1;
1471 root->fs_info->last_trans_committed = cur_trans->transid;
1473 wake_up(&cur_trans->commit_wait);
1475 spin_lock(&root->fs_info->trans_lock);
1476 list_del_init(&cur_trans->list);
1477 spin_unlock(&root->fs_info->trans_lock);
1479 put_transaction(cur_trans);
1480 put_transaction(cur_trans);
1482 trace_btrfs_transaction_commit(root);
1484 btrfs_scrub_continue(root);
1486 if (current->journal_info == trans)
1487 current->journal_info = NULL;
1489 kmem_cache_free(btrfs_trans_handle_cachep, trans);
1491 if (current != root->fs_info->transaction_kthread)
1492 btrfs_run_delayed_iputs(root);
1496 cleanup_transaction:
1497 btrfs_printk(root->fs_info, "Skipping commit of aborted transaction.\n");
1499 if (current->journal_info == trans)
1500 current->journal_info = NULL;
1501 cleanup_transaction(trans, root);
1507 * interface function to delete all the snapshots we have scheduled for deletion
1509 int btrfs_clean_old_snapshots(struct btrfs_root *root)
1512 struct btrfs_fs_info *fs_info = root->fs_info;
1514 spin_lock(&fs_info->trans_lock);
1515 list_splice_init(&fs_info->dead_roots, &list);
1516 spin_unlock(&fs_info->trans_lock);
1518 while (!list_empty(&list)) {
1521 root = list_entry(list.next, struct btrfs_root, root_list);
1522 list_del(&root->root_list);
1524 btrfs_kill_all_delayed_nodes(root);
1526 if (btrfs_header_backref_rev(root->node) <
1527 BTRFS_MIXED_BACKREF_REV)
1528 ret = btrfs_drop_snapshot(root, NULL, 0, 0);
1530 ret =btrfs_drop_snapshot(root, NULL, 1, 0);