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"
31 #define BTRFS_ROOT_TRANS_TAG 0
33 static noinline
void put_transaction(struct btrfs_transaction
*transaction
)
35 WARN_ON(transaction
->use_count
== 0);
36 transaction
->use_count
--;
37 if (transaction
->use_count
== 0) {
38 list_del_init(&transaction
->list
);
39 memset(transaction
, 0, sizeof(*transaction
));
40 kmem_cache_free(btrfs_transaction_cachep
, transaction
);
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
)
55 struct btrfs_transaction
*cur_trans
;
56 cur_trans
= root
->fs_info
->running_transaction
;
58 cur_trans
= kmem_cache_alloc(btrfs_transaction_cachep
,
61 root
->fs_info
->generation
++;
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
->blocked
= 0;
69 cur_trans
->use_count
= 1;
70 cur_trans
->commit_done
= 0;
71 cur_trans
->start_time
= get_seconds();
73 cur_trans
->delayed_refs
.root
= RB_ROOT
;
74 cur_trans
->delayed_refs
.num_entries
= 0;
75 cur_trans
->delayed_refs
.num_heads_ready
= 0;
76 cur_trans
->delayed_refs
.num_heads
= 0;
77 cur_trans
->delayed_refs
.flushing
= 0;
78 cur_trans
->delayed_refs
.run_delayed_start
= 0;
79 spin_lock_init(&cur_trans
->delayed_refs
.lock
);
81 INIT_LIST_HEAD(&cur_trans
->pending_snapshots
);
82 list_add_tail(&cur_trans
->list
, &root
->fs_info
->trans_list
);
83 extent_io_tree_init(&cur_trans
->dirty_pages
,
84 root
->fs_info
->btree_inode
->i_mapping
,
86 spin_lock(&root
->fs_info
->new_trans_lock
);
87 root
->fs_info
->running_transaction
= cur_trans
;
88 spin_unlock(&root
->fs_info
->new_trans_lock
);
90 cur_trans
->num_writers
++;
91 cur_trans
->num_joined
++;
98 * this does all the record keeping required to make sure that a reference
99 * counted root is properly recorded in a given transaction. This is required
100 * to make sure the old root from before we joined the transaction is deleted
101 * when the transaction commits
103 static noinline
int record_root_in_trans(struct btrfs_trans_handle
*trans
,
104 struct btrfs_root
*root
)
106 if (root
->ref_cows
&& root
->last_trans
< trans
->transid
) {
107 WARN_ON(root
== root
->fs_info
->extent_root
);
108 WARN_ON(root
->commit_root
!= root
->node
);
110 radix_tree_tag_set(&root
->fs_info
->fs_roots_radix
,
111 (unsigned long)root
->root_key
.objectid
,
112 BTRFS_ROOT_TRANS_TAG
);
113 root
->last_trans
= trans
->transid
;
114 btrfs_init_reloc_root(trans
, root
);
119 int btrfs_record_root_in_trans(struct btrfs_trans_handle
*trans
,
120 struct btrfs_root
*root
)
125 mutex_lock(&root
->fs_info
->trans_mutex
);
126 if (root
->last_trans
== trans
->transid
) {
127 mutex_unlock(&root
->fs_info
->trans_mutex
);
131 record_root_in_trans(trans
, root
);
132 mutex_unlock(&root
->fs_info
->trans_mutex
);
136 /* wait for commit against the current transaction to become unblocked
137 * when this is done, it is safe to start a new transaction, but the current
138 * transaction might not be fully on disk.
140 static void wait_current_trans(struct btrfs_root
*root
)
142 struct btrfs_transaction
*cur_trans
;
144 cur_trans
= root
->fs_info
->running_transaction
;
145 if (cur_trans
&& cur_trans
->blocked
) {
147 cur_trans
->use_count
++;
149 prepare_to_wait(&root
->fs_info
->transaction_wait
, &wait
,
150 TASK_UNINTERRUPTIBLE
);
151 if (!cur_trans
->blocked
)
153 mutex_unlock(&root
->fs_info
->trans_mutex
);
155 mutex_lock(&root
->fs_info
->trans_mutex
);
157 finish_wait(&root
->fs_info
->transaction_wait
, &wait
);
158 put_transaction(cur_trans
);
162 enum btrfs_trans_type
{
168 static int may_wait_transaction(struct btrfs_root
*root
, int type
)
170 if (!root
->fs_info
->log_root_recovering
&&
171 ((type
== TRANS_START
&& !root
->fs_info
->open_ioctl_trans
) ||
172 type
== TRANS_USERSPACE
))
177 static struct btrfs_trans_handle
*start_transaction(struct btrfs_root
*root
,
178 u64 num_items
, int type
)
180 struct btrfs_trans_handle
*h
;
181 struct btrfs_transaction
*cur_trans
;
185 h
= kmem_cache_alloc(btrfs_trans_handle_cachep
, GFP_NOFS
);
187 return ERR_PTR(-ENOMEM
);
189 mutex_lock(&root
->fs_info
->trans_mutex
);
190 if (may_wait_transaction(root
, type
))
191 wait_current_trans(root
);
193 ret
= join_transaction(root
);
196 cur_trans
= root
->fs_info
->running_transaction
;
197 cur_trans
->use_count
++;
198 mutex_unlock(&root
->fs_info
->trans_mutex
);
200 h
->transid
= cur_trans
->transid
;
201 h
->transaction
= cur_trans
;
204 h
->bytes_reserved
= 0;
205 h
->delayed_ref_updates
= 0;
209 if (cur_trans
->blocked
&& may_wait_transaction(root
, type
)) {
210 btrfs_commit_transaction(h
, root
);
215 ret
= btrfs_trans_reserve_metadata(h
, root
, num_items
,
217 if (ret
== -EAGAIN
) {
218 btrfs_commit_transaction(h
, root
);
222 btrfs_end_transaction(h
, root
);
227 mutex_lock(&root
->fs_info
->trans_mutex
);
228 record_root_in_trans(h
, root
);
229 mutex_unlock(&root
->fs_info
->trans_mutex
);
231 if (!current
->journal_info
&& type
!= TRANS_USERSPACE
)
232 current
->journal_info
= h
;
236 struct btrfs_trans_handle
*btrfs_start_transaction(struct btrfs_root
*root
,
239 return start_transaction(root
, num_items
, TRANS_START
);
241 struct btrfs_trans_handle
*btrfs_join_transaction(struct btrfs_root
*root
,
244 return start_transaction(root
, 0, TRANS_JOIN
);
247 struct btrfs_trans_handle
*btrfs_start_ioctl_transaction(struct btrfs_root
*r
,
250 return start_transaction(r
, 0, TRANS_USERSPACE
);
253 /* wait for a transaction commit to be fully complete */
254 static noinline
int wait_for_commit(struct btrfs_root
*root
,
255 struct btrfs_transaction
*commit
)
258 mutex_lock(&root
->fs_info
->trans_mutex
);
259 while (!commit
->commit_done
) {
260 prepare_to_wait(&commit
->commit_wait
, &wait
,
261 TASK_UNINTERRUPTIBLE
);
262 if (commit
->commit_done
)
264 mutex_unlock(&root
->fs_info
->trans_mutex
);
266 mutex_lock(&root
->fs_info
->trans_mutex
);
268 mutex_unlock(&root
->fs_info
->trans_mutex
);
269 finish_wait(&commit
->commit_wait
, &wait
);
275 * rate limit against the drop_snapshot code. This helps to slow down new
276 * operations if the drop_snapshot code isn't able to keep up.
278 static void throttle_on_drops(struct btrfs_root
*root
)
280 struct btrfs_fs_info
*info
= root
->fs_info
;
281 int harder_count
= 0;
284 if (atomic_read(&info
->throttles
)) {
287 thr
= atomic_read(&info
->throttle_gen
);
290 prepare_to_wait(&info
->transaction_throttle
,
291 &wait
, TASK_UNINTERRUPTIBLE
);
292 if (!atomic_read(&info
->throttles
)) {
293 finish_wait(&info
->transaction_throttle
, &wait
);
297 finish_wait(&info
->transaction_throttle
, &wait
);
298 } while (thr
== atomic_read(&info
->throttle_gen
));
301 if (root
->fs_info
->total_ref_cache_size
> 1 * 1024 * 1024 &&
305 if (root
->fs_info
->total_ref_cache_size
> 5 * 1024 * 1024 &&
309 if (root
->fs_info
->total_ref_cache_size
> 10 * 1024 * 1024 &&
316 void btrfs_throttle(struct btrfs_root
*root
)
318 mutex_lock(&root
->fs_info
->trans_mutex
);
319 if (!root
->fs_info
->open_ioctl_trans
)
320 wait_current_trans(root
);
321 mutex_unlock(&root
->fs_info
->trans_mutex
);
324 static int should_end_transaction(struct btrfs_trans_handle
*trans
,
325 struct btrfs_root
*root
)
328 ret
= btrfs_block_rsv_check(trans
, root
,
329 &root
->fs_info
->global_block_rsv
, 0, 5);
333 int btrfs_should_end_transaction(struct btrfs_trans_handle
*trans
,
334 struct btrfs_root
*root
)
336 struct btrfs_transaction
*cur_trans
= trans
->transaction
;
339 if (cur_trans
->blocked
|| cur_trans
->delayed_refs
.flushing
)
342 updates
= trans
->delayed_ref_updates
;
343 trans
->delayed_ref_updates
= 0;
345 btrfs_run_delayed_refs(trans
, root
, updates
);
347 return should_end_transaction(trans
, root
);
350 static int __btrfs_end_transaction(struct btrfs_trans_handle
*trans
,
351 struct btrfs_root
*root
, int throttle
)
353 struct btrfs_transaction
*cur_trans
= trans
->transaction
;
354 struct btrfs_fs_info
*info
= root
->fs_info
;
358 unsigned long cur
= trans
->delayed_ref_updates
;
359 trans
->delayed_ref_updates
= 0;
361 trans
->transaction
->delayed_refs
.num_heads_ready
> 64) {
362 trans
->delayed_ref_updates
= 0;
365 * do a full flush if the transaction is trying
368 if (trans
->transaction
->delayed_refs
.flushing
)
370 btrfs_run_delayed_refs(trans
, root
, cur
);
377 btrfs_trans_release_metadata(trans
, root
);
379 if (!root
->fs_info
->open_ioctl_trans
&&
380 should_end_transaction(trans
, root
))
381 trans
->transaction
->blocked
= 1;
383 if (cur_trans
->blocked
&& !cur_trans
->in_commit
) {
385 return btrfs_commit_transaction(trans
, root
);
387 wake_up_process(info
->transaction_kthread
);
390 mutex_lock(&info
->trans_mutex
);
391 WARN_ON(cur_trans
!= info
->running_transaction
);
392 WARN_ON(cur_trans
->num_writers
< 1);
393 cur_trans
->num_writers
--;
395 if (waitqueue_active(&cur_trans
->writer_wait
))
396 wake_up(&cur_trans
->writer_wait
);
397 put_transaction(cur_trans
);
398 mutex_unlock(&info
->trans_mutex
);
400 if (current
->journal_info
== trans
)
401 current
->journal_info
= NULL
;
402 memset(trans
, 0, sizeof(*trans
));
403 kmem_cache_free(btrfs_trans_handle_cachep
, trans
);
406 btrfs_run_delayed_iputs(root
);
411 int btrfs_end_transaction(struct btrfs_trans_handle
*trans
,
412 struct btrfs_root
*root
)
414 return __btrfs_end_transaction(trans
, root
, 0);
417 int btrfs_end_transaction_throttle(struct btrfs_trans_handle
*trans
,
418 struct btrfs_root
*root
)
420 return __btrfs_end_transaction(trans
, root
, 1);
424 * when btree blocks are allocated, they have some corresponding bits set for
425 * them in one of two extent_io trees. This is used to make sure all of
426 * those extents are sent to disk but does not wait on them
428 int btrfs_write_marked_extents(struct btrfs_root
*root
,
429 struct extent_io_tree
*dirty_pages
, int mark
)
435 struct inode
*btree_inode
= root
->fs_info
->btree_inode
;
441 ret
= find_first_extent_bit(dirty_pages
, start
, &start
, &end
,
445 while (start
<= end
) {
448 index
= start
>> PAGE_CACHE_SHIFT
;
449 start
= (u64
)(index
+ 1) << PAGE_CACHE_SHIFT
;
450 page
= find_get_page(btree_inode
->i_mapping
, index
);
454 btree_lock_page_hook(page
);
455 if (!page
->mapping
) {
457 page_cache_release(page
);
461 if (PageWriteback(page
)) {
463 wait_on_page_writeback(page
);
466 page_cache_release(page
);
470 err
= write_one_page(page
, 0);
473 page_cache_release(page
);
482 * when btree blocks are allocated, they have some corresponding bits set for
483 * them in one of two extent_io trees. This is used to make sure all of
484 * those extents are on disk for transaction or log commit. We wait
485 * on all the pages and clear them from the dirty pages state tree
487 int btrfs_wait_marked_extents(struct btrfs_root
*root
,
488 struct extent_io_tree
*dirty_pages
, int mark
)
494 struct inode
*btree_inode
= root
->fs_info
->btree_inode
;
500 ret
= find_first_extent_bit(dirty_pages
, start
, &start
, &end
,
505 clear_extent_bits(dirty_pages
, start
, end
, mark
, GFP_NOFS
);
506 while (start
<= end
) {
507 index
= start
>> PAGE_CACHE_SHIFT
;
508 start
= (u64
)(index
+ 1) << PAGE_CACHE_SHIFT
;
509 page
= find_get_page(btree_inode
->i_mapping
, index
);
512 if (PageDirty(page
)) {
513 btree_lock_page_hook(page
);
514 wait_on_page_writeback(page
);
515 err
= write_one_page(page
, 0);
519 wait_on_page_writeback(page
);
520 page_cache_release(page
);
530 * when btree blocks are allocated, they have some corresponding bits set for
531 * them in one of two extent_io trees. This is used to make sure all of
532 * those extents are on disk for transaction or log commit
534 int btrfs_write_and_wait_marked_extents(struct btrfs_root
*root
,
535 struct extent_io_tree
*dirty_pages
, int mark
)
540 ret
= btrfs_write_marked_extents(root
, dirty_pages
, mark
);
541 ret2
= btrfs_wait_marked_extents(root
, dirty_pages
, mark
);
545 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle
*trans
,
546 struct btrfs_root
*root
)
548 if (!trans
|| !trans
->transaction
) {
549 struct inode
*btree_inode
;
550 btree_inode
= root
->fs_info
->btree_inode
;
551 return filemap_write_and_wait(btree_inode
->i_mapping
);
553 return btrfs_write_and_wait_marked_extents(root
,
554 &trans
->transaction
->dirty_pages
,
559 * this is used to update the root pointer in the tree of tree roots.
561 * But, in the case of the extent allocation tree, updating the root
562 * pointer may allocate blocks which may change the root of the extent
565 * So, this loops and repeats and makes sure the cowonly root didn't
566 * change while the root pointer was being updated in the metadata.
568 static int update_cowonly_root(struct btrfs_trans_handle
*trans
,
569 struct btrfs_root
*root
)
574 struct btrfs_root
*tree_root
= root
->fs_info
->tree_root
;
576 old_root_used
= btrfs_root_used(&root
->root_item
);
577 btrfs_write_dirty_block_groups(trans
, root
);
580 old_root_bytenr
= btrfs_root_bytenr(&root
->root_item
);
581 if (old_root_bytenr
== root
->node
->start
&&
582 old_root_used
== btrfs_root_used(&root
->root_item
))
585 btrfs_set_root_node(&root
->root_item
, root
->node
);
586 ret
= btrfs_update_root(trans
, tree_root
,
591 old_root_used
= btrfs_root_used(&root
->root_item
);
592 ret
= btrfs_write_dirty_block_groups(trans
, root
);
596 if (root
!= root
->fs_info
->extent_root
)
597 switch_commit_root(root
);
603 * update all the cowonly tree roots on disk
605 static noinline
int commit_cowonly_roots(struct btrfs_trans_handle
*trans
,
606 struct btrfs_root
*root
)
608 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
609 struct list_head
*next
;
610 struct extent_buffer
*eb
;
613 ret
= btrfs_run_delayed_refs(trans
, root
, (unsigned long)-1);
616 eb
= btrfs_lock_root_node(fs_info
->tree_root
);
617 btrfs_cow_block(trans
, fs_info
->tree_root
, eb
, NULL
, 0, &eb
);
618 btrfs_tree_unlock(eb
);
619 free_extent_buffer(eb
);
621 ret
= btrfs_run_delayed_refs(trans
, root
, (unsigned long)-1);
624 while (!list_empty(&fs_info
->dirty_cowonly_roots
)) {
625 next
= fs_info
->dirty_cowonly_roots
.next
;
627 root
= list_entry(next
, struct btrfs_root
, dirty_list
);
629 update_cowonly_root(trans
, root
);
632 down_write(&fs_info
->extent_commit_sem
);
633 switch_commit_root(fs_info
->extent_root
);
634 up_write(&fs_info
->extent_commit_sem
);
640 * dead roots are old snapshots that need to be deleted. This allocates
641 * a dirty root struct and adds it into the list of dead roots that need to
644 int btrfs_add_dead_root(struct btrfs_root
*root
)
646 mutex_lock(&root
->fs_info
->trans_mutex
);
647 list_add(&root
->root_list
, &root
->fs_info
->dead_roots
);
648 mutex_unlock(&root
->fs_info
->trans_mutex
);
653 * update all the cowonly tree roots on disk
655 static noinline
int commit_fs_roots(struct btrfs_trans_handle
*trans
,
656 struct btrfs_root
*root
)
658 struct btrfs_root
*gang
[8];
659 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
665 ret
= radix_tree_gang_lookup_tag(&fs_info
->fs_roots_radix
,
668 BTRFS_ROOT_TRANS_TAG
);
671 for (i
= 0; i
< ret
; i
++) {
673 radix_tree_tag_clear(&fs_info
->fs_roots_radix
,
674 (unsigned long)root
->root_key
.objectid
,
675 BTRFS_ROOT_TRANS_TAG
);
677 btrfs_free_log(trans
, root
);
678 btrfs_update_reloc_root(trans
, root
);
679 btrfs_orphan_commit_root(trans
, root
);
681 if (root
->commit_root
!= root
->node
) {
682 switch_commit_root(root
);
683 btrfs_set_root_node(&root
->root_item
,
687 err
= btrfs_update_root(trans
, fs_info
->tree_root
,
698 * defrag a given btree. If cacheonly == 1, this won't read from the disk,
699 * otherwise every leaf in the btree is read and defragged.
701 int btrfs_defrag_root(struct btrfs_root
*root
, int cacheonly
)
703 struct btrfs_fs_info
*info
= root
->fs_info
;
704 struct btrfs_trans_handle
*trans
;
708 if (xchg(&root
->defrag_running
, 1))
712 trans
= btrfs_start_transaction(root
, 0);
714 return PTR_ERR(trans
);
716 ret
= btrfs_defrag_leaves(trans
, root
, cacheonly
);
718 nr
= trans
->blocks_used
;
719 btrfs_end_transaction(trans
, root
);
720 btrfs_btree_balance_dirty(info
->tree_root
, nr
);
723 if (root
->fs_info
->closing
|| ret
!= -EAGAIN
)
726 root
->defrag_running
= 0;
732 * when dropping snapshots, we generate a ton of delayed refs, and it makes
733 * sense not to join the transaction while it is trying to flush the current
734 * queue of delayed refs out.
736 * This is used by the drop snapshot code only
738 static noinline
int wait_transaction_pre_flush(struct btrfs_fs_info
*info
)
742 mutex_lock(&info
->trans_mutex
);
743 while (info
->running_transaction
&&
744 info
->running_transaction
->delayed_refs
.flushing
) {
745 prepare_to_wait(&info
->transaction_wait
, &wait
,
746 TASK_UNINTERRUPTIBLE
);
747 mutex_unlock(&info
->trans_mutex
);
751 mutex_lock(&info
->trans_mutex
);
752 finish_wait(&info
->transaction_wait
, &wait
);
754 mutex_unlock(&info
->trans_mutex
);
759 * Given a list of roots that need to be deleted, call btrfs_drop_snapshot on
762 int btrfs_drop_dead_root(struct btrfs_root
*root
)
764 struct btrfs_trans_handle
*trans
;
765 struct btrfs_root
*tree_root
= root
->fs_info
->tree_root
;
771 * we don't want to jump in and create a bunch of
772 * delayed refs if the transaction is starting to close
774 wait_transaction_pre_flush(tree_root
->fs_info
);
775 trans
= btrfs_start_transaction(tree_root
, 1);
778 * we've joined a transaction, make sure it isn't
781 if (trans
->transaction
->delayed_refs
.flushing
) {
782 btrfs_end_transaction(trans
, tree_root
);
786 ret
= btrfs_drop_snapshot(trans
, root
);
790 ret
= btrfs_update_root(trans
, tree_root
,
796 nr
= trans
->blocks_used
;
797 ret
= btrfs_end_transaction(trans
, tree_root
);
800 btrfs_btree_balance_dirty(tree_root
, nr
);
805 ret
= btrfs_del_root(trans
, tree_root
, &root
->root_key
);
808 nr
= trans
->blocks_used
;
809 ret
= btrfs_end_transaction(trans
, tree_root
);
812 free_extent_buffer(root
->node
);
813 free_extent_buffer(root
->commit_root
);
816 btrfs_btree_balance_dirty(tree_root
, nr
);
822 * new snapshots need to be created at a very specific time in the
823 * transaction commit. This does the actual creation
825 static noinline
int create_pending_snapshot(struct btrfs_trans_handle
*trans
,
826 struct btrfs_fs_info
*fs_info
,
827 struct btrfs_pending_snapshot
*pending
)
829 struct btrfs_key key
;
830 struct btrfs_root_item
*new_root_item
;
831 struct btrfs_root
*tree_root
= fs_info
->tree_root
;
832 struct btrfs_root
*root
= pending
->root
;
833 struct btrfs_root
*parent_root
;
834 struct inode
*parent_inode
;
835 struct dentry
*dentry
;
836 struct extent_buffer
*tmp
;
837 struct extent_buffer
*old
;
844 new_root_item
= kmalloc(sizeof(*new_root_item
), GFP_NOFS
);
845 if (!new_root_item
) {
846 pending
->error
= -ENOMEM
;
850 ret
= btrfs_find_free_objectid(trans
, tree_root
, 0, &objectid
);
852 pending
->error
= ret
;
856 btrfs_orphan_pre_snapshot(trans
, pending
, &to_reserve
);
858 if (to_reserve
> 0) {
859 ret
= btrfs_block_rsv_add(trans
, root
, &pending
->block_rsv
,
860 to_reserve
, &retries
);
862 pending
->error
= ret
;
867 key
.objectid
= objectid
;
868 key
.offset
= (u64
)-1;
869 key
.type
= BTRFS_ROOT_ITEM_KEY
;
871 trans
->block_rsv
= &pending
->block_rsv
;
873 dentry
= pending
->dentry
;
874 parent_inode
= dentry
->d_parent
->d_inode
;
875 parent_root
= BTRFS_I(parent_inode
)->root
;
876 record_root_in_trans(trans
, parent_root
);
879 * insert the directory item
881 ret
= btrfs_set_inode_index(parent_inode
, &index
);
883 ret
= btrfs_insert_dir_item(trans
, parent_root
,
884 dentry
->d_name
.name
, dentry
->d_name
.len
,
885 parent_inode
->i_ino
, &key
,
886 BTRFS_FT_DIR
, index
);
889 btrfs_i_size_write(parent_inode
, parent_inode
->i_size
+
890 dentry
->d_name
.len
* 2);
891 ret
= btrfs_update_inode(trans
, parent_root
, parent_inode
);
894 record_root_in_trans(trans
, root
);
895 btrfs_set_root_last_snapshot(&root
->root_item
, trans
->transid
);
896 memcpy(new_root_item
, &root
->root_item
, sizeof(*new_root_item
));
898 old
= btrfs_lock_root_node(root
);
899 btrfs_cow_block(trans
, root
, old
, NULL
, 0, &old
);
900 btrfs_set_lock_blocking(old
);
902 btrfs_copy_root(trans
, root
, old
, &tmp
, objectid
);
903 btrfs_tree_unlock(old
);
904 free_extent_buffer(old
);
906 btrfs_set_root_node(new_root_item
, tmp
);
907 /* record when the snapshot was created in key.offset */
908 key
.offset
= trans
->transid
;
909 ret
= btrfs_insert_root(trans
, tree_root
, &key
, new_root_item
);
910 btrfs_tree_unlock(tmp
);
911 free_extent_buffer(tmp
);
915 * insert root back/forward references
917 ret
= btrfs_add_root_ref(trans
, tree_root
, objectid
,
918 parent_root
->root_key
.objectid
,
919 parent_inode
->i_ino
, index
,
920 dentry
->d_name
.name
, dentry
->d_name
.len
);
923 key
.offset
= (u64
)-1;
924 pending
->snap
= btrfs_read_fs_root_no_name(root
->fs_info
, &key
);
925 BUG_ON(IS_ERR(pending
->snap
));
927 btrfs_orphan_post_snapshot(trans
, pending
);
929 kfree(new_root_item
);
930 btrfs_block_rsv_release(root
, &pending
->block_rsv
, (u64
)-1);
935 * create all the snapshots we've scheduled for creation
937 static noinline
int create_pending_snapshots(struct btrfs_trans_handle
*trans
,
938 struct btrfs_fs_info
*fs_info
)
940 struct btrfs_pending_snapshot
*pending
;
941 struct list_head
*head
= &trans
->transaction
->pending_snapshots
;
944 list_for_each_entry(pending
, head
, list
) {
945 ret
= create_pending_snapshot(trans
, fs_info
, pending
);
951 static void update_super_roots(struct btrfs_root
*root
)
953 struct btrfs_root_item
*root_item
;
954 struct btrfs_super_block
*super
;
956 super
= &root
->fs_info
->super_copy
;
958 root_item
= &root
->fs_info
->chunk_root
->root_item
;
959 super
->chunk_root
= root_item
->bytenr
;
960 super
->chunk_root_generation
= root_item
->generation
;
961 super
->chunk_root_level
= root_item
->level
;
963 root_item
= &root
->fs_info
->tree_root
->root_item
;
964 super
->root
= root_item
->bytenr
;
965 super
->generation
= root_item
->generation
;
966 super
->root_level
= root_item
->level
;
969 int btrfs_transaction_in_commit(struct btrfs_fs_info
*info
)
972 spin_lock(&info
->new_trans_lock
);
973 if (info
->running_transaction
)
974 ret
= info
->running_transaction
->in_commit
;
975 spin_unlock(&info
->new_trans_lock
);
979 int btrfs_transaction_blocked(struct btrfs_fs_info
*info
)
982 spin_lock(&info
->new_trans_lock
);
983 if (info
->running_transaction
)
984 ret
= info
->running_transaction
->blocked
;
985 spin_unlock(&info
->new_trans_lock
);
989 int btrfs_commit_transaction(struct btrfs_trans_handle
*trans
,
990 struct btrfs_root
*root
)
992 unsigned long joined
= 0;
993 unsigned long timeout
= 1;
994 struct btrfs_transaction
*cur_trans
;
995 struct btrfs_transaction
*prev_trans
= NULL
;
999 unsigned long now
= get_seconds();
1000 int flush_on_commit
= btrfs_test_opt(root
, FLUSHONCOMMIT
);
1002 btrfs_run_ordered_operations(root
, 0);
1004 /* make a pass through all the delayed refs we have so far
1005 * any runnings procs may add more while we are here
1007 ret
= btrfs_run_delayed_refs(trans
, root
, 0);
1010 btrfs_trans_release_metadata(trans
, root
);
1012 cur_trans
= trans
->transaction
;
1014 * set the flushing flag so procs in this transaction have to
1015 * start sending their work down.
1017 cur_trans
->delayed_refs
.flushing
= 1;
1019 ret
= btrfs_run_delayed_refs(trans
, root
, 0);
1022 mutex_lock(&root
->fs_info
->trans_mutex
);
1023 if (cur_trans
->in_commit
) {
1024 cur_trans
->use_count
++;
1025 mutex_unlock(&root
->fs_info
->trans_mutex
);
1026 btrfs_end_transaction(trans
, root
);
1028 ret
= wait_for_commit(root
, cur_trans
);
1031 mutex_lock(&root
->fs_info
->trans_mutex
);
1032 put_transaction(cur_trans
);
1033 mutex_unlock(&root
->fs_info
->trans_mutex
);
1038 trans
->transaction
->in_commit
= 1;
1039 trans
->transaction
->blocked
= 1;
1040 if (cur_trans
->list
.prev
!= &root
->fs_info
->trans_list
) {
1041 prev_trans
= list_entry(cur_trans
->list
.prev
,
1042 struct btrfs_transaction
, list
);
1043 if (!prev_trans
->commit_done
) {
1044 prev_trans
->use_count
++;
1045 mutex_unlock(&root
->fs_info
->trans_mutex
);
1047 wait_for_commit(root
, prev_trans
);
1049 mutex_lock(&root
->fs_info
->trans_mutex
);
1050 put_transaction(prev_trans
);
1054 if (now
< cur_trans
->start_time
|| now
- cur_trans
->start_time
< 1)
1058 int snap_pending
= 0;
1059 joined
= cur_trans
->num_joined
;
1060 if (!list_empty(&trans
->transaction
->pending_snapshots
))
1063 WARN_ON(cur_trans
!= trans
->transaction
);
1064 prepare_to_wait(&cur_trans
->writer_wait
, &wait
,
1065 TASK_UNINTERRUPTIBLE
);
1067 if (cur_trans
->num_writers
> 1)
1068 timeout
= MAX_SCHEDULE_TIMEOUT
;
1069 else if (should_grow
)
1072 mutex_unlock(&root
->fs_info
->trans_mutex
);
1074 if (flush_on_commit
|| snap_pending
) {
1075 btrfs_start_delalloc_inodes(root
, 1);
1076 ret
= btrfs_wait_ordered_extents(root
, 0, 1);
1081 * rename don't use btrfs_join_transaction, so, once we
1082 * set the transaction to blocked above, we aren't going
1083 * to get any new ordered operations. We can safely run
1084 * it here and no for sure that nothing new will be added
1087 btrfs_run_ordered_operations(root
, 1);
1090 if (cur_trans
->num_writers
> 1 || should_grow
)
1091 schedule_timeout(timeout
);
1093 mutex_lock(&root
->fs_info
->trans_mutex
);
1094 finish_wait(&cur_trans
->writer_wait
, &wait
);
1095 } while (cur_trans
->num_writers
> 1 ||
1096 (should_grow
&& cur_trans
->num_joined
!= joined
));
1098 ret
= create_pending_snapshots(trans
, root
->fs_info
);
1101 ret
= btrfs_run_delayed_refs(trans
, root
, (unsigned long)-1);
1104 WARN_ON(cur_trans
!= trans
->transaction
);
1106 /* btrfs_commit_tree_roots is responsible for getting the
1107 * various roots consistent with each other. Every pointer
1108 * in the tree of tree roots has to point to the most up to date
1109 * root for every subvolume and other tree. So, we have to keep
1110 * the tree logging code from jumping in and changing any
1113 * At this point in the commit, there can't be any tree-log
1114 * writers, but a little lower down we drop the trans mutex
1115 * and let new people in. By holding the tree_log_mutex
1116 * from now until after the super is written, we avoid races
1117 * with the tree-log code.
1119 mutex_lock(&root
->fs_info
->tree_log_mutex
);
1121 ret
= commit_fs_roots(trans
, root
);
1124 /* commit_fs_roots gets rid of all the tree log roots, it is now
1125 * safe to free the root of tree log roots
1127 btrfs_free_log_root_tree(trans
, root
->fs_info
);
1129 ret
= commit_cowonly_roots(trans
, root
);
1132 btrfs_prepare_extent_commit(trans
, root
);
1134 cur_trans
= root
->fs_info
->running_transaction
;
1135 spin_lock(&root
->fs_info
->new_trans_lock
);
1136 root
->fs_info
->running_transaction
= NULL
;
1137 spin_unlock(&root
->fs_info
->new_trans_lock
);
1139 btrfs_set_root_node(&root
->fs_info
->tree_root
->root_item
,
1140 root
->fs_info
->tree_root
->node
);
1141 switch_commit_root(root
->fs_info
->tree_root
);
1143 btrfs_set_root_node(&root
->fs_info
->chunk_root
->root_item
,
1144 root
->fs_info
->chunk_root
->node
);
1145 switch_commit_root(root
->fs_info
->chunk_root
);
1147 update_super_roots(root
);
1149 if (!root
->fs_info
->log_root_recovering
) {
1150 btrfs_set_super_log_root(&root
->fs_info
->super_copy
, 0);
1151 btrfs_set_super_log_root_level(&root
->fs_info
->super_copy
, 0);
1154 memcpy(&root
->fs_info
->super_for_commit
, &root
->fs_info
->super_copy
,
1155 sizeof(root
->fs_info
->super_copy
));
1157 trans
->transaction
->blocked
= 0;
1159 wake_up(&root
->fs_info
->transaction_wait
);
1161 mutex_unlock(&root
->fs_info
->trans_mutex
);
1162 ret
= btrfs_write_and_wait_transaction(trans
, root
);
1164 write_ctree_super(trans
, root
, 0);
1167 * the super is written, we can safely allow the tree-loggers
1168 * to go about their business
1170 mutex_unlock(&root
->fs_info
->tree_log_mutex
);
1172 btrfs_finish_extent_commit(trans
, root
);
1174 mutex_lock(&root
->fs_info
->trans_mutex
);
1176 cur_trans
->commit_done
= 1;
1178 root
->fs_info
->last_trans_committed
= cur_trans
->transid
;
1180 wake_up(&cur_trans
->commit_wait
);
1182 put_transaction(cur_trans
);
1183 put_transaction(cur_trans
);
1185 mutex_unlock(&root
->fs_info
->trans_mutex
);
1187 if (current
->journal_info
== trans
)
1188 current
->journal_info
= NULL
;
1190 kmem_cache_free(btrfs_trans_handle_cachep
, trans
);
1192 if (current
!= root
->fs_info
->transaction_kthread
)
1193 btrfs_run_delayed_iputs(root
);
1199 * interface function to delete all the snapshots we have scheduled for deletion
1201 int btrfs_clean_old_snapshots(struct btrfs_root
*root
)
1204 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
1206 mutex_lock(&fs_info
->trans_mutex
);
1207 list_splice_init(&fs_info
->dead_roots
, &list
);
1208 mutex_unlock(&fs_info
->trans_mutex
);
1210 while (!list_empty(&list
)) {
1211 root
= list_entry(list
.next
, struct btrfs_root
, root_list
);
1212 list_del(&root
->root_list
);
1214 if (btrfs_header_backref_rev(root
->node
) <
1215 BTRFS_MIXED_BACKREF_REV
)
1216 btrfs_drop_snapshot(root
, 0);
1218 btrfs_drop_snapshot(root
, 1);