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/sched.h>
21 #include <linux/writeback.h>
22 #include <linux/pagemap.h>
25 #include "transaction.h"
27 #include "ref-cache.h"
29 static int total_trans
= 0;
30 extern struct kmem_cache
*btrfs_trans_handle_cachep
;
31 extern struct kmem_cache
*btrfs_transaction_cachep
;
33 #define BTRFS_ROOT_TRANS_TAG 0
36 struct list_head list
;
37 struct btrfs_root
*root
;
38 struct btrfs_root
*latest_root
;
41 static noinline
void put_transaction(struct btrfs_transaction
*transaction
)
43 WARN_ON(transaction
->use_count
== 0);
44 transaction
->use_count
--;
45 if (transaction
->use_count
== 0) {
46 WARN_ON(total_trans
== 0);
48 list_del_init(&transaction
->list
);
49 memset(transaction
, 0, sizeof(*transaction
));
50 kmem_cache_free(btrfs_transaction_cachep
, transaction
);
54 static noinline
int join_transaction(struct btrfs_root
*root
)
56 struct btrfs_transaction
*cur_trans
;
57 cur_trans
= root
->fs_info
->running_transaction
;
59 cur_trans
= kmem_cache_alloc(btrfs_transaction_cachep
,
63 root
->fs_info
->generation
++;
64 root
->fs_info
->last_alloc
= 0;
65 root
->fs_info
->last_data_alloc
= 0;
66 cur_trans
->num_writers
= 1;
67 cur_trans
->num_joined
= 0;
68 cur_trans
->transid
= root
->fs_info
->generation
;
69 init_waitqueue_head(&cur_trans
->writer_wait
);
70 init_waitqueue_head(&cur_trans
->commit_wait
);
71 cur_trans
->in_commit
= 0;
72 cur_trans
->blocked
= 0;
73 cur_trans
->use_count
= 1;
74 cur_trans
->commit_done
= 0;
75 cur_trans
->start_time
= get_seconds();
76 INIT_LIST_HEAD(&cur_trans
->pending_snapshots
);
77 list_add_tail(&cur_trans
->list
, &root
->fs_info
->trans_list
);
78 extent_io_tree_init(&cur_trans
->dirty_pages
,
79 root
->fs_info
->btree_inode
->i_mapping
,
81 spin_lock(&root
->fs_info
->new_trans_lock
);
82 root
->fs_info
->running_transaction
= cur_trans
;
83 spin_unlock(&root
->fs_info
->new_trans_lock
);
85 cur_trans
->num_writers
++;
86 cur_trans
->num_joined
++;
92 static noinline
int record_root_in_trans(struct btrfs_root
*root
)
94 struct dirty_root
*dirty
;
95 u64 running_trans_id
= root
->fs_info
->running_transaction
->transid
;
96 if (root
->ref_cows
&& root
->last_trans
< running_trans_id
) {
97 WARN_ON(root
== root
->fs_info
->extent_root
);
98 if (root
->root_item
.refs
!= 0) {
99 radix_tree_tag_set(&root
->fs_info
->fs_roots_radix
,
100 (unsigned long)root
->root_key
.objectid
,
101 BTRFS_ROOT_TRANS_TAG
);
103 dirty
= kmalloc(sizeof(*dirty
), GFP_NOFS
);
105 dirty
->root
= kmalloc(sizeof(*dirty
->root
), GFP_NOFS
);
106 BUG_ON(!dirty
->root
);
108 dirty
->latest_root
= root
;
109 INIT_LIST_HEAD(&dirty
->list
);
111 root
->commit_root
= btrfs_root_node(root
);
112 root
->dirty_root
= dirty
;
114 memcpy(dirty
->root
, root
, sizeof(*root
));
115 dirty
->root
->ref_tree
= &root
->ref_tree_struct
;
117 spin_lock_init(&dirty
->root
->node_lock
);
118 mutex_init(&dirty
->root
->objectid_mutex
);
119 dirty
->root
->node
= root
->commit_root
;
120 dirty
->root
->commit_root
= NULL
;
124 root
->last_trans
= running_trans_id
;
129 struct btrfs_trans_handle
*start_transaction(struct btrfs_root
*root
,
130 int num_blocks
, int join
)
132 struct btrfs_trans_handle
*h
=
133 kmem_cache_alloc(btrfs_trans_handle_cachep
, GFP_NOFS
);
134 struct btrfs_transaction
*cur_trans
;
137 mutex_lock(&root
->fs_info
->trans_mutex
);
138 cur_trans
= root
->fs_info
->running_transaction
;
139 if (cur_trans
&& cur_trans
->blocked
&& !join
) {
141 cur_trans
->use_count
++;
143 prepare_to_wait(&root
->fs_info
->transaction_wait
, &wait
,
144 TASK_UNINTERRUPTIBLE
);
145 if (cur_trans
->blocked
) {
146 mutex_unlock(&root
->fs_info
->trans_mutex
);
148 mutex_lock(&root
->fs_info
->trans_mutex
);
149 finish_wait(&root
->fs_info
->transaction_wait
,
152 finish_wait(&root
->fs_info
->transaction_wait
,
157 put_transaction(cur_trans
);
159 ret
= join_transaction(root
);
162 record_root_in_trans(root
);
163 h
->transid
= root
->fs_info
->running_transaction
->transid
;
164 h
->transaction
= root
->fs_info
->running_transaction
;
165 h
->blocks_reserved
= num_blocks
;
167 h
->block_group
= NULL
;
168 h
->alloc_exclude_nr
= 0;
169 h
->alloc_exclude_start
= 0;
170 root
->fs_info
->running_transaction
->use_count
++;
171 mutex_unlock(&root
->fs_info
->trans_mutex
);
175 struct btrfs_trans_handle
*btrfs_start_transaction(struct btrfs_root
*root
,
178 return start_transaction(root
, num_blocks
, 0);
180 struct btrfs_trans_handle
*btrfs_join_transaction(struct btrfs_root
*root
,
183 return start_transaction(root
, num_blocks
, 1);
186 static noinline
int wait_for_commit(struct btrfs_root
*root
,
187 struct btrfs_transaction
*commit
)
190 mutex_lock(&root
->fs_info
->trans_mutex
);
191 while(!commit
->commit_done
) {
192 prepare_to_wait(&commit
->commit_wait
, &wait
,
193 TASK_UNINTERRUPTIBLE
);
194 if (commit
->commit_done
)
196 mutex_unlock(&root
->fs_info
->trans_mutex
);
198 mutex_lock(&root
->fs_info
->trans_mutex
);
200 mutex_unlock(&root
->fs_info
->trans_mutex
);
201 finish_wait(&commit
->commit_wait
, &wait
);
205 static int __btrfs_end_transaction(struct btrfs_trans_handle
*trans
,
206 struct btrfs_root
*root
, int throttle
)
208 struct btrfs_transaction
*cur_trans
;
210 mutex_lock(&root
->fs_info
->trans_mutex
);
211 cur_trans
= root
->fs_info
->running_transaction
;
212 WARN_ON(cur_trans
!= trans
->transaction
);
213 WARN_ON(cur_trans
->num_writers
< 1);
214 cur_trans
->num_writers
--;
216 if (waitqueue_active(&cur_trans
->writer_wait
))
217 wake_up(&cur_trans
->writer_wait
);
219 if (throttle
&& atomic_read(&root
->fs_info
->throttles
)) {
221 mutex_unlock(&root
->fs_info
->trans_mutex
);
222 prepare_to_wait(&root
->fs_info
->transaction_throttle
, &wait
,
223 TASK_UNINTERRUPTIBLE
);
224 if (atomic_read(&root
->fs_info
->throttles
))
226 finish_wait(&root
->fs_info
->transaction_throttle
, &wait
);
227 mutex_lock(&root
->fs_info
->trans_mutex
);
230 put_transaction(cur_trans
);
231 mutex_unlock(&root
->fs_info
->trans_mutex
);
232 memset(trans
, 0, sizeof(*trans
));
233 kmem_cache_free(btrfs_trans_handle_cachep
, trans
);
237 int btrfs_end_transaction(struct btrfs_trans_handle
*trans
,
238 struct btrfs_root
*root
)
240 return __btrfs_end_transaction(trans
, root
, 0);
243 int btrfs_end_transaction_throttle(struct btrfs_trans_handle
*trans
,
244 struct btrfs_root
*root
)
246 return __btrfs_end_transaction(trans
, root
, 1);
250 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle
*trans
,
251 struct btrfs_root
*root
)
256 struct extent_io_tree
*dirty_pages
;
258 struct inode
*btree_inode
= root
->fs_info
->btree_inode
;
263 if (!trans
|| !trans
->transaction
) {
264 return filemap_write_and_wait(btree_inode
->i_mapping
);
266 dirty_pages
= &trans
->transaction
->dirty_pages
;
268 ret
= find_first_extent_bit(dirty_pages
, 0, &start
, &end
,
272 clear_extent_dirty(dirty_pages
, start
, end
, GFP_NOFS
);
273 while(start
<= end
) {
274 index
= start
>> PAGE_CACHE_SHIFT
;
275 start
= (u64
)(index
+ 1) << PAGE_CACHE_SHIFT
;
276 page
= find_lock_page(btree_inode
->i_mapping
, index
);
279 if (PageWriteback(page
)) {
281 wait_on_page_writeback(page
);
284 page_cache_release(page
);
288 err
= write_one_page(page
, 0);
291 page_cache_release(page
);
294 err
= filemap_fdatawait(btree_inode
->i_mapping
);
300 static int update_cowonly_root(struct btrfs_trans_handle
*trans
,
301 struct btrfs_root
*root
)
305 struct btrfs_root
*tree_root
= root
->fs_info
->tree_root
;
307 btrfs_write_dirty_block_groups(trans
, root
);
309 old_root_bytenr
= btrfs_root_bytenr(&root
->root_item
);
310 if (old_root_bytenr
== root
->node
->start
)
312 btrfs_set_root_bytenr(&root
->root_item
,
314 btrfs_set_root_level(&root
->root_item
,
315 btrfs_header_level(root
->node
));
316 ret
= btrfs_update_root(trans
, tree_root
,
320 btrfs_write_dirty_block_groups(trans
, root
);
325 int btrfs_commit_tree_roots(struct btrfs_trans_handle
*trans
,
326 struct btrfs_root
*root
)
328 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
329 struct list_head
*next
;
331 while(!list_empty(&fs_info
->dirty_cowonly_roots
)) {
332 next
= fs_info
->dirty_cowonly_roots
.next
;
334 root
= list_entry(next
, struct btrfs_root
, dirty_list
);
335 update_cowonly_root(trans
, root
);
336 if (root
->fs_info
->closing
)
337 btrfs_remove_leaf_refs(root
);
342 int btrfs_add_dead_root(struct btrfs_root
*root
,
343 struct btrfs_root
*latest
,
344 struct list_head
*dead_list
)
346 struct dirty_root
*dirty
;
348 dirty
= kmalloc(sizeof(*dirty
), GFP_NOFS
);
352 dirty
->latest_root
= latest
;
353 list_add(&dirty
->list
, dead_list
);
357 static noinline
int add_dirty_roots(struct btrfs_trans_handle
*trans
,
358 struct radix_tree_root
*radix
,
359 struct list_head
*list
)
361 struct dirty_root
*dirty
;
362 struct btrfs_root
*gang
[8];
363 struct btrfs_root
*root
;
370 ret
= radix_tree_gang_lookup_tag(radix
, (void **)gang
, 0,
372 BTRFS_ROOT_TRANS_TAG
);
375 for (i
= 0; i
< ret
; i
++) {
377 radix_tree_tag_clear(radix
,
378 (unsigned long)root
->root_key
.objectid
,
379 BTRFS_ROOT_TRANS_TAG
);
381 BUG_ON(!root
->ref_tree
);
382 dirty
= root
->dirty_root
;
384 if (root
->commit_root
== root
->node
) {
385 WARN_ON(root
->node
->start
!=
386 btrfs_root_bytenr(&root
->root_item
));
388 free_extent_buffer(root
->commit_root
);
389 root
->commit_root
= NULL
;
394 /* make sure to update the root on disk
395 * so we get any updates to the block used
398 err
= btrfs_update_root(trans
,
399 root
->fs_info
->tree_root
,
405 memset(&root
->root_item
.drop_progress
, 0,
406 sizeof(struct btrfs_disk_key
));
407 root
->root_item
.drop_level
= 0;
408 root
->commit_root
= NULL
;
409 root
->root_key
.offset
= root
->fs_info
->generation
;
410 btrfs_set_root_bytenr(&root
->root_item
,
412 btrfs_set_root_level(&root
->root_item
,
413 btrfs_header_level(root
->node
));
414 err
= btrfs_insert_root(trans
, root
->fs_info
->tree_root
,
420 refs
= btrfs_root_refs(&dirty
->root
->root_item
);
421 btrfs_set_root_refs(&dirty
->root
->root_item
, refs
- 1);
422 err
= btrfs_update_root(trans
, root
->fs_info
->tree_root
,
423 &dirty
->root
->root_key
,
424 &dirty
->root
->root_item
);
428 list_add(&dirty
->list
, list
);
431 free_extent_buffer(dirty
->root
->node
);
440 int btrfs_defrag_root(struct btrfs_root
*root
, int cacheonly
)
442 struct btrfs_fs_info
*info
= root
->fs_info
;
444 struct btrfs_trans_handle
*trans
;
448 if (root
->defrag_running
)
450 trans
= btrfs_start_transaction(root
, 1);
452 root
->defrag_running
= 1;
453 ret
= btrfs_defrag_leaves(trans
, root
, cacheonly
);
454 nr
= trans
->blocks_used
;
455 btrfs_end_transaction(trans
, root
);
456 btrfs_btree_balance_dirty(info
->tree_root
, nr
);
459 trans
= btrfs_start_transaction(root
, 1);
460 if (root
->fs_info
->closing
|| ret
!= -EAGAIN
)
463 root
->defrag_running
= 0;
465 btrfs_end_transaction(trans
, root
);
469 static noinline
int drop_dirty_roots(struct btrfs_root
*tree_root
,
470 struct list_head
*list
)
472 struct dirty_root
*dirty
;
473 struct btrfs_trans_handle
*trans
;
480 while(!list_empty(list
)) {
481 struct btrfs_root
*root
;
483 dirty
= list_entry(list
->prev
, struct dirty_root
, list
);
484 list_del_init(&dirty
->list
);
486 num_bytes
= btrfs_root_used(&dirty
->root
->root_item
);
487 root
= dirty
->latest_root
;
488 atomic_inc(&root
->fs_info
->throttles
);
490 mutex_lock(&root
->fs_info
->drop_mutex
);
492 trans
= btrfs_start_transaction(tree_root
, 1);
493 ret
= btrfs_drop_snapshot(trans
, dirty
->root
);
494 if (ret
!= -EAGAIN
) {
498 err
= btrfs_update_root(trans
,
500 &dirty
->root
->root_key
,
501 &dirty
->root
->root_item
);
504 nr
= trans
->blocks_used
;
505 ret
= btrfs_end_transaction(trans
, tree_root
);
508 mutex_unlock(&root
->fs_info
->drop_mutex
);
509 btrfs_btree_balance_dirty(tree_root
, nr
);
511 mutex_lock(&root
->fs_info
->drop_mutex
);
514 atomic_dec(&root
->fs_info
->throttles
);
515 wake_up(&root
->fs_info
->transaction_throttle
);
517 mutex_lock(&root
->fs_info
->alloc_mutex
);
518 num_bytes
-= btrfs_root_used(&dirty
->root
->root_item
);
519 bytes_used
= btrfs_root_used(&root
->root_item
);
521 record_root_in_trans(root
);
522 btrfs_set_root_used(&root
->root_item
,
523 bytes_used
- num_bytes
);
525 mutex_unlock(&root
->fs_info
->alloc_mutex
);
527 ret
= btrfs_del_root(trans
, tree_root
, &dirty
->root
->root_key
);
532 mutex_unlock(&root
->fs_info
->drop_mutex
);
534 nr
= trans
->blocks_used
;
535 ret
= btrfs_end_transaction(trans
, tree_root
);
538 free_extent_buffer(dirty
->root
->node
);
542 btrfs_btree_balance_dirty(tree_root
, nr
);
548 static noinline
int create_pending_snapshot(struct btrfs_trans_handle
*trans
,
549 struct btrfs_fs_info
*fs_info
,
550 struct btrfs_pending_snapshot
*pending
)
552 struct btrfs_key key
;
553 struct btrfs_root_item
*new_root_item
;
554 struct btrfs_root
*tree_root
= fs_info
->tree_root
;
555 struct btrfs_root
*root
= pending
->root
;
556 struct extent_buffer
*tmp
;
557 struct extent_buffer
*old
;
562 new_root_item
= kmalloc(sizeof(*new_root_item
), GFP_NOFS
);
563 if (!new_root_item
) {
567 ret
= btrfs_find_free_objectid(trans
, tree_root
, 0, &objectid
);
571 memcpy(new_root_item
, &root
->root_item
, sizeof(*new_root_item
));
573 key
.objectid
= objectid
;
575 btrfs_set_key_type(&key
, BTRFS_ROOT_ITEM_KEY
);
577 old
= btrfs_lock_root_node(root
);
578 btrfs_cow_block(trans
, root
, old
, NULL
, 0, &old
);
580 btrfs_copy_root(trans
, root
, old
, &tmp
, objectid
);
581 btrfs_tree_unlock(old
);
582 free_extent_buffer(old
);
584 btrfs_set_root_bytenr(new_root_item
, tmp
->start
);
585 btrfs_set_root_level(new_root_item
, btrfs_header_level(tmp
));
586 ret
= btrfs_insert_root(trans
, root
->fs_info
->tree_root
, &key
,
588 btrfs_tree_unlock(tmp
);
589 free_extent_buffer(tmp
);
594 * insert the directory item
596 key
.offset
= (u64
)-1;
597 namelen
= strlen(pending
->name
);
598 ret
= btrfs_insert_dir_item(trans
, root
->fs_info
->tree_root
,
599 pending
->name
, namelen
,
600 root
->fs_info
->sb
->s_root
->d_inode
->i_ino
,
601 &key
, BTRFS_FT_DIR
, 0);
606 ret
= btrfs_insert_inode_ref(trans
, root
->fs_info
->tree_root
,
607 pending
->name
, strlen(pending
->name
), objectid
,
608 root
->fs_info
->sb
->s_root
->d_inode
->i_ino
, 0);
610 /* Invalidate existing dcache entry for new snapshot. */
611 btrfs_invalidate_dcache_root(root
, pending
->name
, namelen
);
614 kfree(new_root_item
);
618 static noinline
int create_pending_snapshots(struct btrfs_trans_handle
*trans
,
619 struct btrfs_fs_info
*fs_info
)
621 struct btrfs_pending_snapshot
*pending
;
622 struct list_head
*head
= &trans
->transaction
->pending_snapshots
;
625 while(!list_empty(head
)) {
626 pending
= list_entry(head
->next
,
627 struct btrfs_pending_snapshot
, list
);
628 ret
= create_pending_snapshot(trans
, fs_info
, pending
);
630 list_del(&pending
->list
);
631 kfree(pending
->name
);
637 int btrfs_commit_transaction(struct btrfs_trans_handle
*trans
,
638 struct btrfs_root
*root
)
640 unsigned long joined
= 0;
641 unsigned long timeout
= 1;
642 struct btrfs_transaction
*cur_trans
;
643 struct btrfs_transaction
*prev_trans
= NULL
;
644 struct btrfs_root
*chunk_root
= root
->fs_info
->chunk_root
;
645 struct list_head dirty_fs_roots
;
646 struct extent_io_tree
*pinned_copy
;
650 INIT_LIST_HEAD(&dirty_fs_roots
);
652 mutex_lock(&root
->fs_info
->trans_mutex
);
653 if (trans
->transaction
->in_commit
) {
654 cur_trans
= trans
->transaction
;
655 trans
->transaction
->use_count
++;
656 mutex_unlock(&root
->fs_info
->trans_mutex
);
657 btrfs_end_transaction(trans
, root
);
659 ret
= wait_for_commit(root
, cur_trans
);
662 mutex_lock(&root
->fs_info
->trans_mutex
);
663 put_transaction(cur_trans
);
664 mutex_unlock(&root
->fs_info
->trans_mutex
);
669 pinned_copy
= kmalloc(sizeof(*pinned_copy
), GFP_NOFS
);
673 extent_io_tree_init(pinned_copy
,
674 root
->fs_info
->btree_inode
->i_mapping
, GFP_NOFS
);
676 trans
->transaction
->in_commit
= 1;
677 trans
->transaction
->blocked
= 1;
678 cur_trans
= trans
->transaction
;
679 if (cur_trans
->list
.prev
!= &root
->fs_info
->trans_list
) {
680 prev_trans
= list_entry(cur_trans
->list
.prev
,
681 struct btrfs_transaction
, list
);
682 if (!prev_trans
->commit_done
) {
683 prev_trans
->use_count
++;
684 mutex_unlock(&root
->fs_info
->trans_mutex
);
686 wait_for_commit(root
, prev_trans
);
688 mutex_lock(&root
->fs_info
->trans_mutex
);
689 put_transaction(prev_trans
);
694 joined
= cur_trans
->num_joined
;
695 WARN_ON(cur_trans
!= trans
->transaction
);
696 prepare_to_wait(&cur_trans
->writer_wait
, &wait
,
697 TASK_UNINTERRUPTIBLE
);
699 if (cur_trans
->num_writers
> 1)
700 timeout
= MAX_SCHEDULE_TIMEOUT
;
704 mutex_unlock(&root
->fs_info
->trans_mutex
);
706 schedule_timeout(timeout
);
708 mutex_lock(&root
->fs_info
->trans_mutex
);
709 finish_wait(&cur_trans
->writer_wait
, &wait
);
710 } while (cur_trans
->num_writers
> 1 ||
711 (cur_trans
->num_joined
!= joined
));
713 ret
= create_pending_snapshots(trans
, root
->fs_info
);
716 WARN_ON(cur_trans
!= trans
->transaction
);
718 ret
= add_dirty_roots(trans
, &root
->fs_info
->fs_roots_radix
,
722 ret
= btrfs_commit_tree_roots(trans
, root
);
725 cur_trans
= root
->fs_info
->running_transaction
;
726 spin_lock(&root
->fs_info
->new_trans_lock
);
727 root
->fs_info
->running_transaction
= NULL
;
728 spin_unlock(&root
->fs_info
->new_trans_lock
);
729 btrfs_set_super_generation(&root
->fs_info
->super_copy
,
731 btrfs_set_super_root(&root
->fs_info
->super_copy
,
732 root
->fs_info
->tree_root
->node
->start
);
733 btrfs_set_super_root_level(&root
->fs_info
->super_copy
,
734 btrfs_header_level(root
->fs_info
->tree_root
->node
));
736 btrfs_set_super_chunk_root(&root
->fs_info
->super_copy
,
737 chunk_root
->node
->start
);
738 btrfs_set_super_chunk_root_level(&root
->fs_info
->super_copy
,
739 btrfs_header_level(chunk_root
->node
));
740 memcpy(&root
->fs_info
->super_for_commit
, &root
->fs_info
->super_copy
,
741 sizeof(root
->fs_info
->super_copy
));
743 btrfs_copy_pinned(root
, pinned_copy
);
745 trans
->transaction
->blocked
= 0;
746 wake_up(&root
->fs_info
->transaction_throttle
);
747 wake_up(&root
->fs_info
->transaction_wait
);
749 mutex_unlock(&root
->fs_info
->trans_mutex
);
750 ret
= btrfs_write_and_wait_transaction(trans
, root
);
752 write_ctree_super(trans
, root
);
754 btrfs_finish_extent_commit(trans
, root
, pinned_copy
);
755 mutex_lock(&root
->fs_info
->trans_mutex
);
759 cur_trans
->commit_done
= 1;
760 root
->fs_info
->last_trans_committed
= cur_trans
->transid
;
761 wake_up(&cur_trans
->commit_wait
);
762 put_transaction(cur_trans
);
763 put_transaction(cur_trans
);
765 if (root
->fs_info
->closing
)
766 list_splice_init(&root
->fs_info
->dead_roots
, &dirty_fs_roots
);
768 list_splice_init(&dirty_fs_roots
, &root
->fs_info
->dead_roots
);
770 mutex_unlock(&root
->fs_info
->trans_mutex
);
771 kmem_cache_free(btrfs_trans_handle_cachep
, trans
);
773 if (root
->fs_info
->closing
) {
774 drop_dirty_roots(root
->fs_info
->tree_root
, &dirty_fs_roots
);
779 int btrfs_clean_old_snapshots(struct btrfs_root
*root
)
781 struct list_head dirty_roots
;
782 INIT_LIST_HEAD(&dirty_roots
);
784 mutex_lock(&root
->fs_info
->trans_mutex
);
785 list_splice_init(&root
->fs_info
->dead_roots
, &dirty_roots
);
786 mutex_unlock(&root
->fs_info
->trans_mutex
);
788 if (!list_empty(&dirty_roots
)) {
789 drop_dirty_roots(root
, &dirty_roots
);