1 #include <linux/module.h>
5 #include "transaction.h"
7 static int total_trans
= 0;
8 extern struct kmem_cache
*btrfs_trans_handle_cachep
;
9 extern struct kmem_cache
*btrfs_transaction_cachep
;
11 #define BTRFS_ROOT_TRANS_TAG 0
13 #define TRANS_MAGIC 0xE1E10E
14 static void put_transaction(struct btrfs_transaction
*transaction
)
16 WARN_ON(transaction
->use_count
== 0);
17 transaction
->use_count
--;
18 WARN_ON(transaction
->magic
!= TRANS_MAGIC
);
19 if (transaction
->use_count
== 0) {
20 WARN_ON(total_trans
== 0);
22 list_del_init(&transaction
->list
);
23 memset(transaction
, 0, sizeof(*transaction
));
24 kmem_cache_free(btrfs_transaction_cachep
, transaction
);
28 static int join_transaction(struct btrfs_root
*root
)
30 struct btrfs_transaction
*cur_trans
;
31 cur_trans
= root
->fs_info
->running_transaction
;
33 cur_trans
= kmem_cache_alloc(btrfs_transaction_cachep
,
37 root
->fs_info
->generation
++;
38 root
->fs_info
->running_transaction
= cur_trans
;
39 cur_trans
->num_writers
= 0;
40 cur_trans
->transid
= root
->fs_info
->generation
;
41 init_waitqueue_head(&cur_trans
->writer_wait
);
42 init_waitqueue_head(&cur_trans
->commit_wait
);
43 cur_trans
->magic
= TRANS_MAGIC
;
44 cur_trans
->in_commit
= 0;
45 cur_trans
->use_count
= 1;
46 cur_trans
->commit_done
= 0;
47 list_add_tail(&cur_trans
->list
, &root
->fs_info
->trans_list
);
48 init_bit_radix(&cur_trans
->dirty_pages
);
50 cur_trans
->num_writers
++;
54 struct btrfs_trans_handle
*btrfs_start_transaction(struct btrfs_root
*root
,
57 struct btrfs_trans_handle
*h
=
58 kmem_cache_alloc(btrfs_trans_handle_cachep
, GFP_NOFS
);
62 mutex_lock(&root
->fs_info
->trans_mutex
);
63 ret
= join_transaction(root
);
65 running_trans_id
= root
->fs_info
->running_transaction
->transid
;
67 if (root
!= root
->fs_info
->tree_root
&& root
->last_trans
<
69 radix_tree_tag_set(&root
->fs_info
->fs_roots_radix
,
70 (unsigned long)root
->root_key
.objectid
,
71 BTRFS_ROOT_TRANS_TAG
);
72 root
->commit_root
= root
->node
;
75 root
->last_trans
= running_trans_id
;
76 h
->transid
= running_trans_id
;
77 h
->transaction
= root
->fs_info
->running_transaction
;
78 h
->blocks_reserved
= num_blocks
;
80 h
->block_group
= NULL
;
81 root
->fs_info
->running_transaction
->use_count
++;
82 mutex_unlock(&root
->fs_info
->trans_mutex
);
83 h
->magic
= h
->magic2
= TRANS_MAGIC
;
87 int btrfs_end_transaction(struct btrfs_trans_handle
*trans
,
88 struct btrfs_root
*root
)
90 struct btrfs_transaction
*cur_trans
;
92 WARN_ON(trans
->magic
!= TRANS_MAGIC
);
93 WARN_ON(trans
->magic2
!= TRANS_MAGIC
);
94 mutex_lock(&root
->fs_info
->trans_mutex
);
95 cur_trans
= root
->fs_info
->running_transaction
;
96 WARN_ON(cur_trans
->num_writers
< 1);
97 if (waitqueue_active(&cur_trans
->writer_wait
))
98 wake_up(&cur_trans
->writer_wait
);
99 cur_trans
->num_writers
--;
100 put_transaction(cur_trans
);
101 mutex_unlock(&root
->fs_info
->trans_mutex
);
102 memset(trans
, 0, sizeof(*trans
));
103 kmem_cache_free(btrfs_trans_handle_cachep
, trans
);
108 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle
*trans
,
109 struct btrfs_root
*root
)
111 unsigned long gang
[16];
117 struct radix_tree_root
*dirty_pages
;
118 struct inode
*btree_inode
= root
->fs_info
->btree_inode
;
120 if (!trans
|| !trans
->transaction
) {
121 return filemap_write_and_wait(btree_inode
->i_mapping
);
123 dirty_pages
= &trans
->transaction
->dirty_pages
;
125 ret
= find_first_radix_bit(dirty_pages
, gang
, ARRAY_SIZE(gang
));
128 for (i
= 0; i
< ret
; i
++) {
130 clear_radix_bit(dirty_pages
, gang
[i
]);
131 page
= find_lock_page(btree_inode
->i_mapping
,
135 err
= write_one_page(page
, 0);
138 page_cache_release(page
);
141 err
= filemap_fdatawait(btree_inode
->i_mapping
);
147 int btrfs_commit_tree_roots(struct btrfs_trans_handle
*trans
,
148 struct btrfs_root
*root
)
151 u64 old_extent_block
;
152 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
153 struct btrfs_root
*tree_root
= fs_info
->tree_root
;
154 struct btrfs_root
*extent_root
= fs_info
->extent_root
;
155 struct btrfs_root
*dev_root
= fs_info
->dev_root
;
157 if (btrfs_super_device_root(fs_info
->disk_super
) !=
158 bh_blocknr(dev_root
->node
)) {
159 btrfs_set_super_device_root(fs_info
->disk_super
,
160 bh_blocknr(dev_root
->node
));
162 btrfs_write_dirty_block_groups(trans
, extent_root
);
164 old_extent_block
= btrfs_root_blocknr(&extent_root
->root_item
);
165 if (old_extent_block
== bh_blocknr(extent_root
->node
))
167 btrfs_set_root_blocknr(&extent_root
->root_item
,
168 bh_blocknr(extent_root
->node
));
169 ret
= btrfs_update_root(trans
, tree_root
,
170 &extent_root
->root_key
,
171 &extent_root
->root_item
);
173 btrfs_write_dirty_block_groups(trans
, extent_root
);
178 static int wait_for_commit(struct btrfs_root
*root
,
179 struct btrfs_transaction
*commit
)
182 while(!commit
->commit_done
) {
183 prepare_to_wait(&commit
->commit_wait
, &wait
,
184 TASK_UNINTERRUPTIBLE
);
185 if (commit
->commit_done
)
187 mutex_unlock(&root
->fs_info
->trans_mutex
);
189 mutex_lock(&root
->fs_info
->trans_mutex
);
191 finish_wait(&commit
->commit_wait
, &wait
);
196 struct list_head list
;
197 struct btrfs_key snap_key
;
198 struct buffer_head
*commit_root
;
199 struct btrfs_root
*root
;
202 int add_dirty_roots(struct btrfs_trans_handle
*trans
,
203 struct radix_tree_root
*radix
, struct list_head
*list
)
205 struct dirty_root
*dirty
;
206 struct btrfs_root
*gang
[8];
207 struct btrfs_root
*root
;
212 ret
= radix_tree_gang_lookup_tag(radix
, (void **)gang
, 0,
214 BTRFS_ROOT_TRANS_TAG
);
217 for (i
= 0; i
< ret
; i
++) {
219 radix_tree_tag_clear(radix
,
220 (unsigned long)root
->root_key
.objectid
,
221 BTRFS_ROOT_TRANS_TAG
);
222 if (root
->commit_root
== root
->node
) {
223 WARN_ON(bh_blocknr(root
->node
) !=
224 btrfs_root_blocknr(&root
->root_item
));
225 brelse(root
->commit_root
);
226 root
->commit_root
= NULL
;
229 dirty
= kmalloc(sizeof(*dirty
), GFP_NOFS
);
231 memcpy(&dirty
->snap_key
, &root
->root_key
,
232 sizeof(root
->root_key
));
233 dirty
->commit_root
= root
->commit_root
;
234 root
->commit_root
= NULL
;
236 root
->root_key
.offset
= root
->fs_info
->generation
;
237 btrfs_set_root_blocknr(&root
->root_item
,
238 bh_blocknr(root
->node
));
239 err
= btrfs_insert_root(trans
, root
->fs_info
->tree_root
,
243 list_add(&dirty
->list
, list
);
249 int drop_dirty_roots(struct btrfs_root
*tree_root
, struct list_head
*list
)
251 struct dirty_root
*dirty
;
252 struct btrfs_trans_handle
*trans
;
255 while(!list_empty(list
)) {
256 dirty
= list_entry(list
->next
, struct dirty_root
, list
);
257 list_del_init(&dirty
->list
);
258 trans
= btrfs_start_transaction(tree_root
, 1);
259 ret
= btrfs_drop_snapshot(trans
, dirty
->root
,
263 ret
= btrfs_del_root(trans
, tree_root
, &dirty
->snap_key
);
265 ret
= btrfs_end_transaction(trans
, tree_root
);
272 int btrfs_commit_transaction(struct btrfs_trans_handle
*trans
,
273 struct btrfs_root
*root
)
276 struct btrfs_transaction
*cur_trans
;
277 struct btrfs_transaction
*prev_trans
= NULL
;
278 struct list_head dirty_fs_roots
;
281 INIT_LIST_HEAD(&dirty_fs_roots
);
283 mutex_lock(&root
->fs_info
->trans_mutex
);
284 if (trans
->transaction
->in_commit
) {
285 cur_trans
= trans
->transaction
;
286 trans
->transaction
->use_count
++;
287 btrfs_end_transaction(trans
, root
);
288 ret
= wait_for_commit(root
, cur_trans
);
290 put_transaction(cur_trans
);
291 mutex_unlock(&root
->fs_info
->trans_mutex
);
294 cur_trans
= trans
->transaction
;
295 trans
->transaction
->in_commit
= 1;
296 while (trans
->transaction
->num_writers
> 1) {
297 WARN_ON(cur_trans
!= trans
->transaction
);
298 prepare_to_wait(&trans
->transaction
->writer_wait
, &wait
,
299 TASK_UNINTERRUPTIBLE
);
300 if (trans
->transaction
->num_writers
<= 1)
302 mutex_unlock(&root
->fs_info
->trans_mutex
);
304 mutex_lock(&root
->fs_info
->trans_mutex
);
305 finish_wait(&trans
->transaction
->writer_wait
, &wait
);
307 finish_wait(&trans
->transaction
->writer_wait
, &wait
);
308 WARN_ON(cur_trans
!= trans
->transaction
);
309 add_dirty_roots(trans
, &root
->fs_info
->fs_roots_radix
, &dirty_fs_roots
);
310 ret
= btrfs_commit_tree_roots(trans
, root
);
312 cur_trans
= root
->fs_info
->running_transaction
;
313 root
->fs_info
->running_transaction
= NULL
;
314 if (cur_trans
->list
.prev
!= &root
->fs_info
->trans_list
) {
315 prev_trans
= list_entry(cur_trans
->list
.prev
,
316 struct btrfs_transaction
, list
);
317 if (prev_trans
->commit_done
)
320 prev_trans
->use_count
++;
322 mutex_unlock(&root
->fs_info
->trans_mutex
);
323 mutex_unlock(&root
->fs_info
->fs_mutex
);
324 ret
= btrfs_write_and_wait_transaction(trans
, root
);
326 mutex_lock(&root
->fs_info
->trans_mutex
);
327 wait_for_commit(root
, prev_trans
);
328 put_transaction(prev_trans
);
329 mutex_unlock(&root
->fs_info
->trans_mutex
);
331 btrfs_set_super_generation(root
->fs_info
->disk_super
,
334 write_ctree_super(trans
, root
);
336 mutex_lock(&root
->fs_info
->fs_mutex
);
337 btrfs_finish_extent_commit(trans
, root
);
338 mutex_lock(&root
->fs_info
->trans_mutex
);
339 cur_trans
->commit_done
= 1;
340 wake_up(&cur_trans
->commit_wait
);
341 put_transaction(cur_trans
);
342 put_transaction(cur_trans
);
343 mutex_unlock(&root
->fs_info
->trans_mutex
);
344 kmem_cache_free(btrfs_trans_handle_cachep
, trans
);
346 drop_dirty_roots(root
->fs_info
->tree_root
, &dirty_fs_roots
);