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 static int total_trans
= 0;
28 extern struct kmem_cache
*btrfs_trans_handle_cachep
;
29 extern struct kmem_cache
*btrfs_transaction_cachep
;
31 static struct workqueue_struct
*trans_wq
;
33 #define BTRFS_ROOT_TRANS_TAG 0
34 #define BTRFS_ROOT_DEFRAG_TAG 1
36 static noinline
void put_transaction(struct btrfs_transaction
*transaction
)
38 WARN_ON(transaction
->use_count
== 0);
39 transaction
->use_count
--;
40 if (transaction
->use_count
== 0) {
41 WARN_ON(total_trans
== 0);
43 list_del_init(&transaction
->list
);
44 memset(transaction
, 0, sizeof(*transaction
));
45 kmem_cache_free(btrfs_transaction_cachep
, transaction
);
49 static noinline
int join_transaction(struct btrfs_root
*root
)
51 struct btrfs_transaction
*cur_trans
;
52 cur_trans
= root
->fs_info
->running_transaction
;
54 cur_trans
= kmem_cache_alloc(btrfs_transaction_cachep
,
58 root
->fs_info
->generation
++;
59 root
->fs_info
->running_transaction
= cur_trans
;
60 root
->fs_info
->last_alloc
= 0;
61 root
->fs_info
->last_data_alloc
= 0;
62 cur_trans
->num_writers
= 1;
63 cur_trans
->num_joined
= 0;
64 cur_trans
->transid
= root
->fs_info
->generation
;
65 init_waitqueue_head(&cur_trans
->writer_wait
);
66 init_waitqueue_head(&cur_trans
->commit_wait
);
67 cur_trans
->in_commit
= 0;
68 cur_trans
->use_count
= 1;
69 cur_trans
->commit_done
= 0;
70 cur_trans
->start_time
= get_seconds();
71 INIT_LIST_HEAD(&cur_trans
->pending_snapshots
);
72 list_add_tail(&cur_trans
->list
, &root
->fs_info
->trans_list
);
73 btrfs_ordered_inode_tree_init(&cur_trans
->ordered_inode_tree
);
74 extent_io_tree_init(&cur_trans
->dirty_pages
,
75 root
->fs_info
->btree_inode
->i_mapping
,
78 cur_trans
->num_writers
++;
79 cur_trans
->num_joined
++;
85 static noinline
int record_root_in_trans(struct btrfs_root
*root
)
87 u64 running_trans_id
= root
->fs_info
->running_transaction
->transid
;
88 if (root
->ref_cows
&& root
->last_trans
< running_trans_id
) {
89 WARN_ON(root
== root
->fs_info
->extent_root
);
90 if (root
->root_item
.refs
!= 0) {
91 radix_tree_tag_set(&root
->fs_info
->fs_roots_radix
,
92 (unsigned long)root
->root_key
.objectid
,
93 BTRFS_ROOT_TRANS_TAG
);
94 radix_tree_tag_set(&root
->fs_info
->fs_roots_radix
,
95 (unsigned long)root
->root_key
.objectid
,
96 BTRFS_ROOT_DEFRAG_TAG
);
97 root
->commit_root
= root
->node
;
98 extent_buffer_get(root
->node
);
102 root
->last_trans
= running_trans_id
;
107 struct btrfs_trans_handle
*btrfs_start_transaction(struct btrfs_root
*root
,
110 struct btrfs_trans_handle
*h
=
111 kmem_cache_alloc(btrfs_trans_handle_cachep
, GFP_NOFS
);
114 mutex_lock(&root
->fs_info
->trans_mutex
);
115 ret
= join_transaction(root
);
118 record_root_in_trans(root
);
119 h
->transid
= root
->fs_info
->running_transaction
->transid
;
120 h
->transaction
= root
->fs_info
->running_transaction
;
121 h
->blocks_reserved
= num_blocks
;
123 h
->block_group
= NULL
;
124 h
->alloc_exclude_nr
= 0;
125 h
->alloc_exclude_start
= 0;
126 root
->fs_info
->running_transaction
->use_count
++;
127 mutex_unlock(&root
->fs_info
->trans_mutex
);
131 int btrfs_end_transaction(struct btrfs_trans_handle
*trans
,
132 struct btrfs_root
*root
)
134 struct btrfs_transaction
*cur_trans
;
136 mutex_lock(&root
->fs_info
->trans_mutex
);
137 cur_trans
= root
->fs_info
->running_transaction
;
138 WARN_ON(cur_trans
!= trans
->transaction
);
139 WARN_ON(cur_trans
->num_writers
< 1);
140 cur_trans
->num_writers
--;
141 if (waitqueue_active(&cur_trans
->writer_wait
))
142 wake_up(&cur_trans
->writer_wait
);
143 put_transaction(cur_trans
);
144 mutex_unlock(&root
->fs_info
->trans_mutex
);
145 memset(trans
, 0, sizeof(*trans
));
146 kmem_cache_free(btrfs_trans_handle_cachep
, trans
);
151 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle
*trans
,
152 struct btrfs_root
*root
)
157 struct extent_io_tree
*dirty_pages
;
159 struct inode
*btree_inode
= root
->fs_info
->btree_inode
;
164 if (!trans
|| !trans
->transaction
) {
165 return filemap_write_and_wait(btree_inode
->i_mapping
);
167 dirty_pages
= &trans
->transaction
->dirty_pages
;
169 ret
= find_first_extent_bit(dirty_pages
, 0, &start
, &end
,
173 clear_extent_dirty(dirty_pages
, start
, end
, GFP_NOFS
);
174 while(start
<= end
) {
175 index
= start
>> PAGE_CACHE_SHIFT
;
176 start
= (u64
)(index
+ 1) << PAGE_CACHE_SHIFT
;
177 page
= find_lock_page(btree_inode
->i_mapping
, index
);
180 if (PageWriteback(page
)) {
182 wait_on_page_writeback(page
);
185 page_cache_release(page
);
189 err
= write_one_page(page
, 0);
192 page_cache_release(page
);
195 err
= filemap_fdatawait(btree_inode
->i_mapping
);
201 static int update_cowonly_root(struct btrfs_trans_handle
*trans
,
202 struct btrfs_root
*root
)
206 struct btrfs_root
*tree_root
= root
->fs_info
->tree_root
;
208 btrfs_write_dirty_block_groups(trans
, root
);
210 old_root_bytenr
= btrfs_root_bytenr(&root
->root_item
);
211 if (old_root_bytenr
== root
->node
->start
)
213 btrfs_set_root_bytenr(&root
->root_item
,
215 btrfs_set_root_level(&root
->root_item
,
216 btrfs_header_level(root
->node
));
217 ret
= btrfs_update_root(trans
, tree_root
,
221 btrfs_write_dirty_block_groups(trans
, root
);
226 int btrfs_commit_tree_roots(struct btrfs_trans_handle
*trans
,
227 struct btrfs_root
*root
)
229 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
230 struct list_head
*next
;
232 while(!list_empty(&fs_info
->dirty_cowonly_roots
)) {
233 next
= fs_info
->dirty_cowonly_roots
.next
;
235 root
= list_entry(next
, struct btrfs_root
, dirty_list
);
236 update_cowonly_root(trans
, root
);
241 static noinline
int wait_for_commit(struct btrfs_root
*root
,
242 struct btrfs_transaction
*commit
)
245 mutex_lock(&root
->fs_info
->trans_mutex
);
246 while(!commit
->commit_done
) {
247 prepare_to_wait(&commit
->commit_wait
, &wait
,
248 TASK_UNINTERRUPTIBLE
);
249 if (commit
->commit_done
)
251 mutex_unlock(&root
->fs_info
->trans_mutex
);
253 mutex_lock(&root
->fs_info
->trans_mutex
);
255 mutex_unlock(&root
->fs_info
->trans_mutex
);
256 finish_wait(&commit
->commit_wait
, &wait
);
261 struct list_head list
;
262 struct btrfs_root
*root
;
263 struct btrfs_root
*latest_root
;
266 int btrfs_add_dead_root(struct btrfs_root
*root
,
267 struct btrfs_root
*latest
,
268 struct list_head
*dead_list
)
270 struct dirty_root
*dirty
;
272 dirty
= kmalloc(sizeof(*dirty
), GFP_NOFS
);
276 dirty
->latest_root
= latest
;
277 list_add(&dirty
->list
, dead_list
);
281 static noinline
int add_dirty_roots(struct btrfs_trans_handle
*trans
,
282 struct radix_tree_root
*radix
,
283 struct list_head
*list
)
285 struct dirty_root
*dirty
;
286 struct btrfs_root
*gang
[8];
287 struct btrfs_root
*root
;
294 ret
= radix_tree_gang_lookup_tag(radix
, (void **)gang
, 0,
296 BTRFS_ROOT_TRANS_TAG
);
299 for (i
= 0; i
< ret
; i
++) {
301 radix_tree_tag_clear(radix
,
302 (unsigned long)root
->root_key
.objectid
,
303 BTRFS_ROOT_TRANS_TAG
);
304 if (root
->commit_root
== root
->node
) {
305 WARN_ON(root
->node
->start
!=
306 btrfs_root_bytenr(&root
->root_item
));
307 free_extent_buffer(root
->commit_root
);
308 root
->commit_root
= NULL
;
310 /* make sure to update the root on disk
311 * so we get any updates to the block used
314 err
= btrfs_update_root(trans
,
315 root
->fs_info
->tree_root
,
320 dirty
= kmalloc(sizeof(*dirty
), GFP_NOFS
);
322 dirty
->root
= kmalloc(sizeof(*dirty
->root
), GFP_NOFS
);
323 BUG_ON(!dirty
->root
);
325 memset(&root
->root_item
.drop_progress
, 0,
326 sizeof(struct btrfs_disk_key
));
327 root
->root_item
.drop_level
= 0;
329 memcpy(dirty
->root
, root
, sizeof(*root
));
330 dirty
->root
->node
= root
->commit_root
;
331 dirty
->latest_root
= root
;
332 root
->commit_root
= NULL
;
334 root
->root_key
.offset
= root
->fs_info
->generation
;
335 btrfs_set_root_bytenr(&root
->root_item
,
337 btrfs_set_root_level(&root
->root_item
,
338 btrfs_header_level(root
->node
));
339 err
= btrfs_insert_root(trans
, root
->fs_info
->tree_root
,
345 refs
= btrfs_root_refs(&dirty
->root
->root_item
);
346 btrfs_set_root_refs(&dirty
->root
->root_item
, refs
- 1);
347 err
= btrfs_update_root(trans
, root
->fs_info
->tree_root
,
348 &dirty
->root
->root_key
,
349 &dirty
->root
->root_item
);
353 list_add(&dirty
->list
, list
);
364 int btrfs_defrag_root(struct btrfs_root
*root
, int cacheonly
)
366 struct btrfs_fs_info
*info
= root
->fs_info
;
368 struct btrfs_trans_handle
*trans
;
371 if (root
->defrag_running
)
373 trans
= btrfs_start_transaction(root
, 1);
375 root
->defrag_running
= 1;
376 ret
= btrfs_defrag_leaves(trans
, root
, cacheonly
);
377 nr
= trans
->blocks_used
;
378 btrfs_end_transaction(trans
, root
);
379 mutex_unlock(&info
->fs_mutex
);
380 btrfs_btree_balance_dirty(info
->tree_root
, nr
);
383 mutex_lock(&info
->fs_mutex
);
384 trans
= btrfs_start_transaction(root
, 1);
388 root
->defrag_running
= 0;
389 radix_tree_tag_clear(&info
->fs_roots_radix
,
390 (unsigned long)root
->root_key
.objectid
,
391 BTRFS_ROOT_DEFRAG_TAG
);
392 btrfs_end_transaction(trans
, root
);
396 int btrfs_defrag_dirty_roots(struct btrfs_fs_info
*info
)
398 struct btrfs_root
*gang
[1];
399 struct btrfs_root
*root
;
406 ret
= radix_tree_gang_lookup_tag(&info
->fs_roots_radix
,
409 BTRFS_ROOT_DEFRAG_TAG
);
412 for (i
= 0; i
< ret
; i
++) {
414 last
= root
->root_key
.objectid
+ 1;
415 btrfs_defrag_root(root
, 1);
418 btrfs_defrag_root(info
->extent_root
, 1);
422 static noinline
int drop_dirty_roots(struct btrfs_root
*tree_root
,
423 struct list_head
*list
)
425 struct dirty_root
*dirty
;
426 struct btrfs_trans_handle
*trans
;
433 while(!list_empty(list
)) {
434 struct btrfs_root
*root
;
436 mutex_lock(&tree_root
->fs_info
->fs_mutex
);
437 dirty
= list_entry(list
->next
, struct dirty_root
, list
);
438 list_del_init(&dirty
->list
);
440 num_bytes
= btrfs_root_used(&dirty
->root
->root_item
);
441 root
= dirty
->latest_root
;
442 root
->fs_info
->throttles
++;
445 trans
= btrfs_start_transaction(tree_root
, 1);
446 ret
= btrfs_drop_snapshot(trans
, dirty
->root
);
447 if (ret
!= -EAGAIN
) {
451 err
= btrfs_update_root(trans
,
453 &dirty
->root
->root_key
,
454 &dirty
->root
->root_item
);
457 nr
= trans
->blocks_used
;
458 ret
= btrfs_end_transaction(trans
, tree_root
);
460 mutex_unlock(&tree_root
->fs_info
->fs_mutex
);
461 btrfs_btree_balance_dirty(tree_root
, nr
);
463 mutex_lock(&tree_root
->fs_info
->fs_mutex
);
466 root
->fs_info
->throttles
--;
468 num_bytes
-= btrfs_root_used(&dirty
->root
->root_item
);
469 bytes_used
= btrfs_root_used(&root
->root_item
);
471 record_root_in_trans(root
);
472 btrfs_set_root_used(&root
->root_item
,
473 bytes_used
- num_bytes
);
475 ret
= btrfs_del_root(trans
, tree_root
, &dirty
->root
->root_key
);
480 nr
= trans
->blocks_used
;
481 ret
= btrfs_end_transaction(trans
, tree_root
);
484 free_extent_buffer(dirty
->root
->node
);
487 mutex_unlock(&tree_root
->fs_info
->fs_mutex
);
489 btrfs_btree_balance_dirty(tree_root
, nr
);
495 int btrfs_write_ordered_inodes(struct btrfs_trans_handle
*trans
,
496 struct btrfs_root
*root
)
498 struct btrfs_transaction
*cur_trans
= trans
->transaction
;
500 u64 root_objectid
= 0;
504 root
->fs_info
->throttles
++;
506 ret
= btrfs_find_first_ordered_inode(
507 &cur_trans
->ordered_inode_tree
,
508 &root_objectid
, &objectid
, &inode
);
512 mutex_unlock(&root
->fs_info
->trans_mutex
);
513 mutex_unlock(&root
->fs_info
->fs_mutex
);
515 if (S_ISREG(inode
->i_mode
)) {
516 atomic_inc(&BTRFS_I(inode
)->ordered_writeback
);
517 filemap_fdatawrite(inode
->i_mapping
);
518 atomic_dec(&BTRFS_I(inode
)->ordered_writeback
);
522 mutex_lock(&root
->fs_info
->fs_mutex
);
523 mutex_lock(&root
->fs_info
->trans_mutex
);
528 ret
= btrfs_find_del_first_ordered_inode(
529 &cur_trans
->ordered_inode_tree
,
530 &root_objectid
, &objectid
, &inode
);
533 mutex_unlock(&root
->fs_info
->trans_mutex
);
534 mutex_unlock(&root
->fs_info
->fs_mutex
);
536 if (S_ISREG(inode
->i_mode
)) {
537 atomic_inc(&BTRFS_I(inode
)->ordered_writeback
);
538 filemap_write_and_wait(inode
->i_mapping
);
539 atomic_dec(&BTRFS_I(inode
)->ordered_writeback
);
541 atomic_dec(&inode
->i_count
);
544 mutex_lock(&root
->fs_info
->fs_mutex
);
545 mutex_lock(&root
->fs_info
->trans_mutex
);
547 root
->fs_info
->throttles
--;
551 static noinline
int create_pending_snapshot(struct btrfs_trans_handle
*trans
,
552 struct btrfs_fs_info
*fs_info
,
553 struct btrfs_pending_snapshot
*pending
)
555 struct btrfs_key key
;
556 struct btrfs_root_item
*new_root_item
;
557 struct btrfs_root
*tree_root
= fs_info
->tree_root
;
558 struct btrfs_root
*root
= pending
->root
;
559 struct extent_buffer
*tmp
;
563 new_root_item
= kmalloc(sizeof(*new_root_item
), GFP_NOFS
);
564 if (!new_root_item
) {
568 ret
= btrfs_find_free_objectid(trans
, tree_root
, 0, &objectid
);
572 memcpy(new_root_item
, &root
->root_item
, sizeof(*new_root_item
));
574 key
.objectid
= objectid
;
576 btrfs_set_key_type(&key
, BTRFS_ROOT_ITEM_KEY
);
578 extent_buffer_get(root
->node
);
579 btrfs_cow_block(trans
, root
, root
->node
, NULL
, 0, &tmp
);
580 free_extent_buffer(tmp
);
582 btrfs_copy_root(trans
, root
, root
->node
, &tmp
, objectid
);
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 free_extent_buffer(tmp
);
593 * insert the directory item
595 key
.offset
= (u64
)-1;
596 ret
= btrfs_insert_dir_item(trans
, root
->fs_info
->tree_root
,
597 pending
->name
, strlen(pending
->name
),
598 root
->fs_info
->sb
->s_root
->d_inode
->i_ino
,
604 ret
= btrfs_insert_inode_ref(trans
, root
->fs_info
->tree_root
,
605 pending
->name
, strlen(pending
->name
), objectid
,
606 root
->fs_info
->sb
->s_root
->d_inode
->i_ino
);
608 kfree(new_root_item
);
612 static noinline
int create_pending_snapshots(struct btrfs_trans_handle
*trans
,
613 struct btrfs_fs_info
*fs_info
)
615 struct btrfs_pending_snapshot
*pending
;
616 struct list_head
*head
= &trans
->transaction
->pending_snapshots
;
619 while(!list_empty(head
)) {
620 pending
= list_entry(head
->next
,
621 struct btrfs_pending_snapshot
, list
);
622 ret
= create_pending_snapshot(trans
, fs_info
, pending
);
624 list_del(&pending
->list
);
625 kfree(pending
->name
);
631 int btrfs_commit_transaction(struct btrfs_trans_handle
*trans
,
632 struct btrfs_root
*root
)
634 unsigned long joined
= 0;
635 unsigned long timeout
= 1;
636 struct btrfs_transaction
*cur_trans
;
637 struct btrfs_transaction
*prev_trans
= NULL
;
638 struct btrfs_root
*chunk_root
= root
->fs_info
->chunk_root
;
639 struct list_head dirty_fs_roots
;
640 struct extent_io_tree
*pinned_copy
;
644 INIT_LIST_HEAD(&dirty_fs_roots
);
646 mutex_lock(&root
->fs_info
->trans_mutex
);
647 if (trans
->transaction
->in_commit
) {
648 cur_trans
= trans
->transaction
;
649 trans
->transaction
->use_count
++;
650 mutex_unlock(&root
->fs_info
->trans_mutex
);
651 btrfs_end_transaction(trans
, root
);
653 mutex_unlock(&root
->fs_info
->fs_mutex
);
654 ret
= wait_for_commit(root
, cur_trans
);
657 mutex_lock(&root
->fs_info
->trans_mutex
);
658 put_transaction(cur_trans
);
659 mutex_unlock(&root
->fs_info
->trans_mutex
);
661 mutex_lock(&root
->fs_info
->fs_mutex
);
665 pinned_copy
= kmalloc(sizeof(*pinned_copy
), GFP_NOFS
);
669 extent_io_tree_init(pinned_copy
,
670 root
->fs_info
->btree_inode
->i_mapping
, GFP_NOFS
);
672 trans
->transaction
->in_commit
= 1;
673 cur_trans
= trans
->transaction
;
674 if (cur_trans
->list
.prev
!= &root
->fs_info
->trans_list
) {
675 prev_trans
= list_entry(cur_trans
->list
.prev
,
676 struct btrfs_transaction
, list
);
677 if (!prev_trans
->commit_done
) {
678 prev_trans
->use_count
++;
679 mutex_unlock(&root
->fs_info
->fs_mutex
);
680 mutex_unlock(&root
->fs_info
->trans_mutex
);
682 wait_for_commit(root
, prev_trans
);
684 mutex_lock(&root
->fs_info
->fs_mutex
);
685 mutex_lock(&root
->fs_info
->trans_mutex
);
686 put_transaction(prev_trans
);
691 joined
= cur_trans
->num_joined
;
692 WARN_ON(cur_trans
!= trans
->transaction
);
693 prepare_to_wait(&cur_trans
->writer_wait
, &wait
,
694 TASK_UNINTERRUPTIBLE
);
696 if (cur_trans
->num_writers
> 1)
697 timeout
= MAX_SCHEDULE_TIMEOUT
;
701 mutex_unlock(&root
->fs_info
->fs_mutex
);
702 mutex_unlock(&root
->fs_info
->trans_mutex
);
704 schedule_timeout(timeout
);
706 mutex_lock(&root
->fs_info
->fs_mutex
);
707 mutex_lock(&root
->fs_info
->trans_mutex
);
708 finish_wait(&cur_trans
->writer_wait
, &wait
);
709 ret
= btrfs_write_ordered_inodes(trans
, root
);
711 } while (cur_trans
->num_writers
> 1 ||
712 (cur_trans
->num_joined
!= joined
));
714 ret
= create_pending_snapshots(trans
, root
->fs_info
);
717 WARN_ON(cur_trans
!= trans
->transaction
);
719 ret
= add_dirty_roots(trans
, &root
->fs_info
->fs_roots_radix
,
723 ret
= btrfs_commit_tree_roots(trans
, root
);
726 cur_trans
= root
->fs_info
->running_transaction
;
727 spin_lock(&root
->fs_info
->new_trans_lock
);
728 root
->fs_info
->running_transaction
= NULL
;
729 spin_unlock(&root
->fs_info
->new_trans_lock
);
730 btrfs_set_super_generation(&root
->fs_info
->super_copy
,
732 btrfs_set_super_root(&root
->fs_info
->super_copy
,
733 root
->fs_info
->tree_root
->node
->start
);
734 btrfs_set_super_root_level(&root
->fs_info
->super_copy
,
735 btrfs_header_level(root
->fs_info
->tree_root
->node
));
737 btrfs_set_super_chunk_root(&root
->fs_info
->super_copy
,
738 chunk_root
->node
->start
);
739 btrfs_set_super_chunk_root_level(&root
->fs_info
->super_copy
,
740 btrfs_header_level(chunk_root
->node
));
741 write_extent_buffer(root
->fs_info
->sb_buffer
,
742 &root
->fs_info
->super_copy
, 0,
743 sizeof(root
->fs_info
->super_copy
));
745 btrfs_copy_pinned(root
, pinned_copy
);
747 mutex_unlock(&root
->fs_info
->trans_mutex
);
748 mutex_unlock(&root
->fs_info
->fs_mutex
);
749 ret
= btrfs_write_and_wait_transaction(trans
, root
);
751 write_ctree_super(trans
, root
);
753 mutex_lock(&root
->fs_info
->fs_mutex
);
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 mutex_unlock(&root
->fs_info
->fs_mutex
);
775 drop_dirty_roots(root
->fs_info
->tree_root
, &dirty_fs_roots
);
776 mutex_lock(&root
->fs_info
->fs_mutex
);
781 int btrfs_clean_old_snapshots(struct btrfs_root
*root
)
783 struct list_head dirty_roots
;
784 INIT_LIST_HEAD(&dirty_roots
);
786 mutex_lock(&root
->fs_info
->trans_mutex
);
787 list_splice_init(&root
->fs_info
->dead_roots
, &dirty_roots
);
788 mutex_unlock(&root
->fs_info
->trans_mutex
);
790 if (!list_empty(&dirty_roots
)) {
791 drop_dirty_roots(root
, &dirty_roots
);
795 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
796 void btrfs_transaction_cleaner(void *p
)
798 void btrfs_transaction_cleaner(struct work_struct
*work
)
801 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
802 struct btrfs_fs_info
*fs_info
= p
;
804 struct btrfs_fs_info
*fs_info
= container_of(work
,
805 struct btrfs_fs_info
,
809 struct btrfs_root
*root
= fs_info
->tree_root
;
810 struct btrfs_transaction
*cur
;
811 struct btrfs_trans_handle
*trans
;
813 unsigned long delay
= HZ
* 30;
816 mutex_lock(&root
->fs_info
->fs_mutex
);
817 if (root
->fs_info
->closing
)
820 mutex_lock(&root
->fs_info
->trans_mutex
);
821 cur
= root
->fs_info
->running_transaction
;
823 mutex_unlock(&root
->fs_info
->trans_mutex
);
827 if (now
< cur
->start_time
|| now
- cur
->start_time
< 30) {
828 mutex_unlock(&root
->fs_info
->trans_mutex
);
832 mutex_unlock(&root
->fs_info
->trans_mutex
);
833 btrfs_defrag_dirty_roots(root
->fs_info
);
834 trans
= btrfs_start_transaction(root
, 1);
835 ret
= btrfs_commit_transaction(trans
, root
);
837 mutex_unlock(&root
->fs_info
->fs_mutex
);
838 btrfs_clean_old_snapshots(root
);
839 btrfs_transaction_queue_work(root
, delay
);
842 void btrfs_transaction_queue_work(struct btrfs_root
*root
, int delay
)
844 if (!root
->fs_info
->closing
)
845 queue_delayed_work(trans_wq
, &root
->fs_info
->trans_work
, delay
);
848 void btrfs_transaction_flush_work(struct btrfs_root
*root
)
850 cancel_delayed_work(&root
->fs_info
->trans_work
);
851 flush_workqueue(trans_wq
);
854 void __init
btrfs_init_transaction_sys(void)
856 trans_wq
= create_workqueue("btrfs-transaction");
859 void btrfs_exit_transaction_sys(void)
861 destroy_workqueue(trans_wq
);