Btrfs: Fix balance_level to free the middle block if there is room in the left one
[linux-2.6-block.git] / fs / btrfs / transaction.c
CommitLineData
6cbd5570
CM
1/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
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.
7 *
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.
12 *
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.
17 */
18
79154b1b 19#include <linux/fs.h>
34088780 20#include <linux/sched.h>
d3c2fdcf 21#include <linux/writeback.h>
5f39d397 22#include <linux/pagemap.h>
79154b1b
CM
23#include "ctree.h"
24#include "disk-io.h"
25#include "transaction.h"
26
78fae27e 27static int total_trans = 0;
2c90e5d6
CM
28extern struct kmem_cache *btrfs_trans_handle_cachep;
29extern struct kmem_cache *btrfs_transaction_cachep;
30
08607c1b
CM
31static struct workqueue_struct *trans_wq;
32
0f7d52f4 33#define BTRFS_ROOT_TRANS_TAG 0
6702ed49 34#define BTRFS_ROOT_DEFRAG_TAG 1
0f7d52f4 35
80b6794d 36static noinline void put_transaction(struct btrfs_transaction *transaction)
79154b1b 37{
2c90e5d6 38 WARN_ON(transaction->use_count == 0);
79154b1b 39 transaction->use_count--;
78fae27e
CM
40 if (transaction->use_count == 0) {
41 WARN_ON(total_trans == 0);
42 total_trans--;
8fd17795 43 list_del_init(&transaction->list);
2c90e5d6
CM
44 memset(transaction, 0, sizeof(*transaction));
45 kmem_cache_free(btrfs_transaction_cachep, transaction);
78fae27e 46 }
79154b1b
CM
47}
48
80b6794d 49static noinline int join_transaction(struct btrfs_root *root)
79154b1b
CM
50{
51 struct btrfs_transaction *cur_trans;
52 cur_trans = root->fs_info->running_transaction;
53 if (!cur_trans) {
2c90e5d6
CM
54 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep,
55 GFP_NOFS);
78fae27e 56 total_trans++;
79154b1b 57 BUG_ON(!cur_trans);
0f7d52f4 58 root->fs_info->generation++;
79154b1b 59 root->fs_info->running_transaction = cur_trans;
e18e4809 60 root->fs_info->last_alloc = 0;
4529ba49 61 root->fs_info->last_data_alloc = 0;
15ee9bc7
JB
62 cur_trans->num_writers = 1;
63 cur_trans->num_joined = 0;
0f7d52f4 64 cur_trans->transid = root->fs_info->generation;
79154b1b
CM
65 init_waitqueue_head(&cur_trans->writer_wait);
66 init_waitqueue_head(&cur_trans->commit_wait);
67 cur_trans->in_commit = 0;
d5719762 68 cur_trans->use_count = 1;
79154b1b 69 cur_trans->commit_done = 0;
08607c1b 70 cur_trans->start_time = get_seconds();
3063d29f 71 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
8fd17795 72 list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
dc17ff8f 73 btrfs_ordered_inode_tree_init(&cur_trans->ordered_inode_tree);
d1310b2e 74 extent_io_tree_init(&cur_trans->dirty_pages,
5f39d397
CM
75 root->fs_info->btree_inode->i_mapping,
76 GFP_NOFS);
15ee9bc7
JB
77 } else {
78 cur_trans->num_writers++;
79 cur_trans->num_joined++;
79154b1b 80 }
15ee9bc7 81
79154b1b
CM
82 return 0;
83}
84
80b6794d 85static noinline int record_root_in_trans(struct btrfs_root *root)
6702ed49
CM
86{
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;
5f39d397 98 extent_buffer_get(root->node);
6702ed49
CM
99 } else {
100 WARN_ON(1);
101 }
102 root->last_trans = running_trans_id;
103 }
104 return 0;
105}
106
79154b1b
CM
107struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
108 int num_blocks)
109{
2c90e5d6
CM
110 struct btrfs_trans_handle *h =
111 kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
79154b1b
CM
112 int ret;
113
114 mutex_lock(&root->fs_info->trans_mutex);
115 ret = join_transaction(root);
116 BUG_ON(ret);
0f7d52f4 117
6702ed49
CM
118 record_root_in_trans(root);
119 h->transid = root->fs_info->running_transaction->transid;
79154b1b
CM
120 h->transaction = root->fs_info->running_transaction;
121 h->blocks_reserved = num_blocks;
122 h->blocks_used = 0;
31f3c99b 123 h->block_group = NULL;
26b8003f
CM
124 h->alloc_exclude_nr = 0;
125 h->alloc_exclude_start = 0;
79154b1b
CM
126 root->fs_info->running_transaction->use_count++;
127 mutex_unlock(&root->fs_info->trans_mutex);
128 return h;
129}
130
131int btrfs_end_transaction(struct btrfs_trans_handle *trans,
132 struct btrfs_root *root)
133{
134 struct btrfs_transaction *cur_trans;
d6e4a428 135
79154b1b
CM
136 mutex_lock(&root->fs_info->trans_mutex);
137 cur_trans = root->fs_info->running_transaction;
ccd467d6 138 WARN_ON(cur_trans != trans->transaction);
d5719762 139 WARN_ON(cur_trans->num_writers < 1);
ccd467d6 140 cur_trans->num_writers--;
79154b1b
CM
141 if (waitqueue_active(&cur_trans->writer_wait))
142 wake_up(&cur_trans->writer_wait);
79154b1b
CM
143 put_transaction(cur_trans);
144 mutex_unlock(&root->fs_info->trans_mutex);
d6025579 145 memset(trans, 0, sizeof(*trans));
2c90e5d6 146 kmem_cache_free(btrfs_trans_handle_cachep, trans);
79154b1b
CM
147 return 0;
148}
149
150
151int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
152 struct btrfs_root *root)
153{
7c4452b9 154 int ret;
7c4452b9
CM
155 int err;
156 int werr = 0;
d1310b2e 157 struct extent_io_tree *dirty_pages;
7c4452b9 158 struct page *page;
7c4452b9 159 struct inode *btree_inode = root->fs_info->btree_inode;
5f39d397
CM
160 u64 start;
161 u64 end;
162 unsigned long index;
7c4452b9
CM
163
164 if (!trans || !trans->transaction) {
165 return filemap_write_and_wait(btree_inode->i_mapping);
166 }
167 dirty_pages = &trans->transaction->dirty_pages;
168 while(1) {
5f39d397
CM
169 ret = find_first_extent_bit(dirty_pages, 0, &start, &end,
170 EXTENT_DIRTY);
171 if (ret)
7c4452b9 172 break;
5f39d397
CM
173 clear_extent_dirty(dirty_pages, start, end, GFP_NOFS);
174 while(start <= end) {
175 index = start >> PAGE_CACHE_SHIFT;
35ebb934 176 start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
5f39d397 177 page = find_lock_page(btree_inode->i_mapping, index);
7c4452b9
CM
178 if (!page)
179 continue;
6702ed49
CM
180 if (PageWriteback(page)) {
181 if (PageDirty(page))
182 wait_on_page_writeback(page);
183 else {
184 unlock_page(page);
185 page_cache_release(page);
186 continue;
187 }
188 }
7c4452b9
CM
189 err = write_one_page(page, 0);
190 if (err)
191 werr = err;
192 page_cache_release(page);
193 }
194 }
195 err = filemap_fdatawait(btree_inode->i_mapping);
196 if (err)
197 werr = err;
198 return werr;
79154b1b
CM
199}
200
0b86a832
CM
201static int update_cowonly_root(struct btrfs_trans_handle *trans,
202 struct btrfs_root *root)
79154b1b
CM
203{
204 int ret;
0b86a832
CM
205 u64 old_root_bytenr;
206 struct btrfs_root *tree_root = root->fs_info->tree_root;
79154b1b 207
0b86a832 208 btrfs_write_dirty_block_groups(trans, root);
79154b1b 209 while(1) {
0b86a832
CM
210 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
211 if (old_root_bytenr == root->node->start)
79154b1b 212 break;
0b86a832
CM
213 btrfs_set_root_bytenr(&root->root_item,
214 root->node->start);
215 btrfs_set_root_level(&root->root_item,
216 btrfs_header_level(root->node));
79154b1b 217 ret = btrfs_update_root(trans, tree_root,
0b86a832
CM
218 &root->root_key,
219 &root->root_item);
79154b1b 220 BUG_ON(ret);
0b86a832
CM
221 btrfs_write_dirty_block_groups(trans, root);
222 }
223 return 0;
224}
225
226int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans,
227 struct btrfs_root *root)
228{
229 struct btrfs_fs_info *fs_info = root->fs_info;
230 struct list_head *next;
231
232 while(!list_empty(&fs_info->dirty_cowonly_roots)) {
233 next = fs_info->dirty_cowonly_roots.next;
234 list_del_init(next);
235 root = list_entry(next, struct btrfs_root, dirty_list);
236 update_cowonly_root(trans, root);
79154b1b
CM
237 }
238 return 0;
239}
240
80b6794d
CM
241static noinline int wait_for_commit(struct btrfs_root *root,
242 struct btrfs_transaction *commit)
79154b1b
CM
243{
244 DEFINE_WAIT(wait);
ccd467d6 245 mutex_lock(&root->fs_info->trans_mutex);
79154b1b
CM
246 while(!commit->commit_done) {
247 prepare_to_wait(&commit->commit_wait, &wait,
248 TASK_UNINTERRUPTIBLE);
249 if (commit->commit_done)
250 break;
251 mutex_unlock(&root->fs_info->trans_mutex);
252 schedule();
253 mutex_lock(&root->fs_info->trans_mutex);
254 }
ccd467d6 255 mutex_unlock(&root->fs_info->trans_mutex);
79154b1b
CM
256 finish_wait(&commit->commit_wait, &wait);
257 return 0;
258}
259
0f7d52f4
CM
260struct dirty_root {
261 struct list_head list;
0f7d52f4 262 struct btrfs_root *root;
58176a96 263 struct btrfs_root *latest_root;
0f7d52f4
CM
264};
265
5ce14bbc
CM
266int btrfs_add_dead_root(struct btrfs_root *root,
267 struct btrfs_root *latest,
268 struct list_head *dead_list)
5eda7b5e
CM
269{
270 struct dirty_root *dirty;
271
272 dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
273 if (!dirty)
274 return -ENOMEM;
5eda7b5e 275 dirty->root = root;
5ce14bbc 276 dirty->latest_root = latest;
5eda7b5e
CM
277 list_add(&dirty->list, dead_list);
278 return 0;
279}
280
80b6794d
CM
281static noinline int add_dirty_roots(struct btrfs_trans_handle *trans,
282 struct radix_tree_root *radix,
283 struct list_head *list)
0f7d52f4
CM
284{
285 struct dirty_root *dirty;
286 struct btrfs_root *gang[8];
287 struct btrfs_root *root;
288 int i;
289 int ret;
54aa1f4d 290 int err = 0;
5eda7b5e 291 u32 refs;
54aa1f4d 292
0f7d52f4
CM
293 while(1) {
294 ret = radix_tree_gang_lookup_tag(radix, (void **)gang, 0,
295 ARRAY_SIZE(gang),
296 BTRFS_ROOT_TRANS_TAG);
297 if (ret == 0)
298 break;
299 for (i = 0; i < ret; i++) {
300 root = gang[i];
2619ba1f
CM
301 radix_tree_tag_clear(radix,
302 (unsigned long)root->root_key.objectid,
303 BTRFS_ROOT_TRANS_TAG);
0f7d52f4 304 if (root->commit_root == root->node) {
db94535d
CM
305 WARN_ON(root->node->start !=
306 btrfs_root_bytenr(&root->root_item));
5f39d397 307 free_extent_buffer(root->commit_root);
0f7d52f4 308 root->commit_root = NULL;
58176a96
JB
309
310 /* make sure to update the root on disk
311 * so we get any updates to the block used
312 * counts
313 */
314 err = btrfs_update_root(trans,
315 root->fs_info->tree_root,
316 &root->root_key,
317 &root->root_item);
0f7d52f4
CM
318 continue;
319 }
320 dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
321 BUG_ON(!dirty);
9f3a7427
CM
322 dirty->root = kmalloc(sizeof(*dirty->root), GFP_NOFS);
323 BUG_ON(!dirty->root);
324
325 memset(&root->root_item.drop_progress, 0,
326 sizeof(struct btrfs_disk_key));
327 root->root_item.drop_level = 0;
328
329 memcpy(dirty->root, root, sizeof(*root));
330 dirty->root->node = root->commit_root;
58176a96 331 dirty->latest_root = root;
0f7d52f4 332 root->commit_root = NULL;
5eda7b5e 333
0f7d52f4 334 root->root_key.offset = root->fs_info->generation;
db94535d
CM
335 btrfs_set_root_bytenr(&root->root_item,
336 root->node->start);
337 btrfs_set_root_level(&root->root_item,
338 btrfs_header_level(root->node));
0f7d52f4
CM
339 err = btrfs_insert_root(trans, root->fs_info->tree_root,
340 &root->root_key,
341 &root->root_item);
54aa1f4d
CM
342 if (err)
343 break;
9f3a7427
CM
344
345 refs = btrfs_root_refs(&dirty->root->root_item);
346 btrfs_set_root_refs(&dirty->root->root_item, refs - 1);
5eda7b5e 347 err = btrfs_update_root(trans, root->fs_info->tree_root,
9f3a7427
CM
348 &dirty->root->root_key,
349 &dirty->root->root_item);
5eda7b5e
CM
350
351 BUG_ON(err);
9f3a7427 352 if (refs == 1) {
5eda7b5e 353 list_add(&dirty->list, list);
9f3a7427
CM
354 } else {
355 WARN_ON(1);
356 kfree(dirty->root);
5eda7b5e 357 kfree(dirty);
9f3a7427 358 }
0f7d52f4
CM
359 }
360 }
54aa1f4d 361 return err;
0f7d52f4
CM
362}
363
e9d0b13b
CM
364int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
365{
366 struct btrfs_fs_info *info = root->fs_info;
367 int ret;
368 struct btrfs_trans_handle *trans;
d3c2fdcf 369 unsigned long nr;
e9d0b13b
CM
370
371 if (root->defrag_running)
372 return 0;
e9d0b13b 373 trans = btrfs_start_transaction(root, 1);
6b80053d 374 while (1) {
e9d0b13b
CM
375 root->defrag_running = 1;
376 ret = btrfs_defrag_leaves(trans, root, cacheonly);
d3c2fdcf 377 nr = trans->blocks_used;
e9d0b13b
CM
378 btrfs_end_transaction(trans, root);
379 mutex_unlock(&info->fs_mutex);
d3c2fdcf 380 btrfs_btree_balance_dirty(info->tree_root, nr);
e9d0b13b
CM
381 cond_resched();
382
383 mutex_lock(&info->fs_mutex);
384 trans = btrfs_start_transaction(root, 1);
385 if (ret != -EAGAIN)
386 break;
387 }
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);
393 return 0;
394}
395
6702ed49
CM
396int btrfs_defrag_dirty_roots(struct btrfs_fs_info *info)
397{
398 struct btrfs_root *gang[1];
399 struct btrfs_root *root;
6702ed49
CM
400 int i;
401 int ret;
402 int err = 0;
403 u64 last = 0;
404
6702ed49
CM
405 while(1) {
406 ret = radix_tree_gang_lookup_tag(&info->fs_roots_radix,
407 (void **)gang, last,
408 ARRAY_SIZE(gang),
409 BTRFS_ROOT_DEFRAG_TAG);
410 if (ret == 0)
411 break;
412 for (i = 0; i < ret; i++) {
413 root = gang[i];
414 last = root->root_key.objectid + 1;
f510cfec 415 btrfs_defrag_root(root, 1);
6702ed49
CM
416 }
417 }
6b80053d 418 btrfs_defrag_root(info->extent_root, 1);
6702ed49
CM
419 return err;
420}
421
80b6794d
CM
422static noinline int drop_dirty_roots(struct btrfs_root *tree_root,
423 struct list_head *list)
0f7d52f4
CM
424{
425 struct dirty_root *dirty;
426 struct btrfs_trans_handle *trans;
d3c2fdcf 427 unsigned long nr;
db94535d
CM
428 u64 num_bytes;
429 u64 bytes_used;
54aa1f4d 430 int ret = 0;
9f3a7427
CM
431 int err;
432
0f7d52f4 433 while(!list_empty(list)) {
58176a96
JB
434 struct btrfs_root *root;
435
facda1e7 436 mutex_lock(&tree_root->fs_info->fs_mutex);
0f7d52f4
CM
437 dirty = list_entry(list->next, struct dirty_root, list);
438 list_del_init(&dirty->list);
5eda7b5e 439
db94535d 440 num_bytes = btrfs_root_used(&dirty->root->root_item);
58176a96 441 root = dirty->latest_root;
e2008b61 442 root->fs_info->throttles++;
58176a96 443
9f3a7427
CM
444 while(1) {
445 trans = btrfs_start_transaction(tree_root, 1);
446 ret = btrfs_drop_snapshot(trans, dirty->root);
447 if (ret != -EAGAIN) {
448 break;
449 }
58176a96 450
9f3a7427
CM
451 err = btrfs_update_root(trans,
452 tree_root,
453 &dirty->root->root_key,
454 &dirty->root->root_item);
455 if (err)
456 ret = err;
d3c2fdcf 457 nr = trans->blocks_used;
9f3a7427
CM
458 ret = btrfs_end_transaction(trans, tree_root);
459 BUG_ON(ret);
f4468e94 460 mutex_unlock(&tree_root->fs_info->fs_mutex);
d3c2fdcf 461 btrfs_btree_balance_dirty(tree_root, nr);
4dc11904 462 cond_resched();
f4468e94 463 mutex_lock(&tree_root->fs_info->fs_mutex);
9f3a7427 464 }
0f7d52f4 465 BUG_ON(ret);
e2008b61 466 root->fs_info->throttles--;
58176a96 467
db94535d
CM
468 num_bytes -= btrfs_root_used(&dirty->root->root_item);
469 bytes_used = btrfs_root_used(&root->root_item);
470 if (num_bytes) {
58176a96 471 record_root_in_trans(root);
5f39d397 472 btrfs_set_root_used(&root->root_item,
db94535d 473 bytes_used - num_bytes);
58176a96 474 }
9f3a7427 475 ret = btrfs_del_root(trans, tree_root, &dirty->root->root_key);
58176a96
JB
476 if (ret) {
477 BUG();
54aa1f4d 478 break;
58176a96 479 }
d3c2fdcf 480 nr = trans->blocks_used;
0f7d52f4
CM
481 ret = btrfs_end_transaction(trans, tree_root);
482 BUG_ON(ret);
5eda7b5e 483
f510cfec 484 free_extent_buffer(dirty->root->node);
9f3a7427 485 kfree(dirty->root);
0f7d52f4 486 kfree(dirty);
facda1e7 487 mutex_unlock(&tree_root->fs_info->fs_mutex);
d3c2fdcf
CM
488
489 btrfs_btree_balance_dirty(tree_root, nr);
4dc11904 490 cond_resched();
0f7d52f4 491 }
54aa1f4d 492 return ret;
0f7d52f4
CM
493}
494
dc17ff8f
CM
495int btrfs_write_ordered_inodes(struct btrfs_trans_handle *trans,
496 struct btrfs_root *root)
497{
498 struct btrfs_transaction *cur_trans = trans->transaction;
499 struct inode *inode;
500 u64 root_objectid = 0;
501 u64 objectid = 0;
dc17ff8f
CM
502 int ret;
503
e2008b61 504 root->fs_info->throttles++;
dc17ff8f
CM
505 while(1) {
506 ret = btrfs_find_first_ordered_inode(
507 &cur_trans->ordered_inode_tree,
4d5e74bc 508 &root_objectid, &objectid, &inode);
dc17ff8f
CM
509 if (!ret)
510 break;
511
512 mutex_unlock(&root->fs_info->trans_mutex);
513 mutex_unlock(&root->fs_info->fs_mutex);
4d5e74bc
CM
514
515 if (S_ISREG(inode->i_mode))
516 filemap_fdatawrite(inode->i_mapping);
517 iput(inode);
518
dc17ff8f
CM
519 mutex_lock(&root->fs_info->fs_mutex);
520 mutex_lock(&root->fs_info->trans_mutex);
521 }
522 while(1) {
523 root_objectid = 0;
524 objectid = 0;
525 ret = btrfs_find_del_first_ordered_inode(
526 &cur_trans->ordered_inode_tree,
4d5e74bc 527 &root_objectid, &objectid, &inode);
dc17ff8f
CM
528 if (!ret)
529 break;
530 mutex_unlock(&root->fs_info->trans_mutex);
531 mutex_unlock(&root->fs_info->fs_mutex);
4d5e74bc
CM
532
533 if (S_ISREG(inode->i_mode))
534 filemap_write_and_wait(inode->i_mapping);
535 atomic_dec(&inode->i_count);
536 iput(inode);
537
dc17ff8f
CM
538 mutex_lock(&root->fs_info->fs_mutex);
539 mutex_lock(&root->fs_info->trans_mutex);
540 }
e2008b61 541 root->fs_info->throttles--;
3063d29f
CM
542 return 0;
543}
544
80b6794d 545static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
3063d29f
CM
546 struct btrfs_fs_info *fs_info,
547 struct btrfs_pending_snapshot *pending)
548{
549 struct btrfs_key key;
80b6794d 550 struct btrfs_root_item *new_root_item;
3063d29f
CM
551 struct btrfs_root *tree_root = fs_info->tree_root;
552 struct btrfs_root *root = pending->root;
553 struct extent_buffer *tmp;
554 int ret;
555 u64 objectid;
556
80b6794d
CM
557 new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
558 if (!new_root_item) {
559 ret = -ENOMEM;
560 goto fail;
561 }
3063d29f
CM
562 ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid);
563 if (ret)
564 goto fail;
565
80b6794d 566 memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
3063d29f
CM
567
568 key.objectid = objectid;
569 key.offset = 1;
570 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
571
572 extent_buffer_get(root->node);
573 btrfs_cow_block(trans, root, root->node, NULL, 0, &tmp);
574 free_extent_buffer(tmp);
575
576 btrfs_copy_root(trans, root, root->node, &tmp, objectid);
577
80b6794d
CM
578 btrfs_set_root_bytenr(new_root_item, tmp->start);
579 btrfs_set_root_level(new_root_item, btrfs_header_level(tmp));
3063d29f 580 ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
80b6794d 581 new_root_item);
3063d29f
CM
582 free_extent_buffer(tmp);
583 if (ret)
584 goto fail;
585
586 /*
587 * insert the directory item
588 */
589 key.offset = (u64)-1;
590 ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
591 pending->name, strlen(pending->name),
592 root->fs_info->sb->s_root->d_inode->i_ino,
593 &key, BTRFS_FT_DIR);
594
595 if (ret)
596 goto fail;
597
598 ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root,
599 pending->name, strlen(pending->name), objectid,
600 root->fs_info->sb->s_root->d_inode->i_ino);
601fail:
80b6794d 602 kfree(new_root_item);
3063d29f
CM
603 return ret;
604}
605
80b6794d
CM
606static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
607 struct btrfs_fs_info *fs_info)
3063d29f
CM
608{
609 struct btrfs_pending_snapshot *pending;
610 struct list_head *head = &trans->transaction->pending_snapshots;
611 int ret;
612
613 while(!list_empty(head)) {
614 pending = list_entry(head->next,
615 struct btrfs_pending_snapshot, list);
616 ret = create_pending_snapshot(trans, fs_info, pending);
617 BUG_ON(ret);
618 list_del(&pending->list);
619 kfree(pending->name);
620 kfree(pending);
621 }
dc17ff8f
CM
622 return 0;
623}
624
79154b1b
CM
625int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
626 struct btrfs_root *root)
627{
15ee9bc7
JB
628 unsigned long joined = 0;
629 unsigned long timeout = 1;
79154b1b 630 struct btrfs_transaction *cur_trans;
8fd17795 631 struct btrfs_transaction *prev_trans = NULL;
0b86a832 632 struct btrfs_root *chunk_root = root->fs_info->chunk_root;
0f7d52f4 633 struct list_head dirty_fs_roots;
d1310b2e 634 struct extent_io_tree *pinned_copy;
79154b1b 635 DEFINE_WAIT(wait);
15ee9bc7 636 int ret;
79154b1b 637
0f7d52f4 638 INIT_LIST_HEAD(&dirty_fs_roots);
d6e4a428 639
79154b1b
CM
640 mutex_lock(&root->fs_info->trans_mutex);
641 if (trans->transaction->in_commit) {
642 cur_trans = trans->transaction;
643 trans->transaction->use_count++;
ccd467d6 644 mutex_unlock(&root->fs_info->trans_mutex);
79154b1b 645 btrfs_end_transaction(trans, root);
ccd467d6
CM
646
647 mutex_unlock(&root->fs_info->fs_mutex);
79154b1b
CM
648 ret = wait_for_commit(root, cur_trans);
649 BUG_ON(ret);
15ee9bc7
JB
650
651 mutex_lock(&root->fs_info->trans_mutex);
79154b1b 652 put_transaction(cur_trans);
15ee9bc7
JB
653 mutex_unlock(&root->fs_info->trans_mutex);
654
ccd467d6 655 mutex_lock(&root->fs_info->fs_mutex);
79154b1b
CM
656 return 0;
657 }
4313b399
CM
658
659 pinned_copy = kmalloc(sizeof(*pinned_copy), GFP_NOFS);
660 if (!pinned_copy)
661 return -ENOMEM;
662
d1310b2e 663 extent_io_tree_init(pinned_copy,
4313b399
CM
664 root->fs_info->btree_inode->i_mapping, GFP_NOFS);
665
2c90e5d6 666 trans->transaction->in_commit = 1;
ccd467d6
CM
667 cur_trans = trans->transaction;
668 if (cur_trans->list.prev != &root->fs_info->trans_list) {
669 prev_trans = list_entry(cur_trans->list.prev,
670 struct btrfs_transaction, list);
671 if (!prev_trans->commit_done) {
672 prev_trans->use_count++;
673 mutex_unlock(&root->fs_info->fs_mutex);
674 mutex_unlock(&root->fs_info->trans_mutex);
675
676 wait_for_commit(root, prev_trans);
ccd467d6
CM
677
678 mutex_lock(&root->fs_info->fs_mutex);
679 mutex_lock(&root->fs_info->trans_mutex);
15ee9bc7 680 put_transaction(prev_trans);
ccd467d6
CM
681 }
682 }
15ee9bc7
JB
683
684 do {
685 joined = cur_trans->num_joined;
2c90e5d6 686 WARN_ON(cur_trans != trans->transaction);
15ee9bc7 687 prepare_to_wait(&cur_trans->writer_wait, &wait,
79154b1b 688 TASK_UNINTERRUPTIBLE);
15ee9bc7
JB
689
690 if (cur_trans->num_writers > 1)
691 timeout = MAX_SCHEDULE_TIMEOUT;
692 else
693 timeout = 1;
694
ccd467d6 695 mutex_unlock(&root->fs_info->fs_mutex);
79154b1b 696 mutex_unlock(&root->fs_info->trans_mutex);
15ee9bc7
JB
697
698 schedule_timeout(timeout);
699
ccd467d6 700 mutex_lock(&root->fs_info->fs_mutex);
79154b1b 701 mutex_lock(&root->fs_info->trans_mutex);
15ee9bc7 702 finish_wait(&cur_trans->writer_wait, &wait);
dc17ff8f
CM
703 ret = btrfs_write_ordered_inodes(trans, root);
704
15ee9bc7
JB
705 } while (cur_trans->num_writers > 1 ||
706 (cur_trans->num_joined != joined));
707
3063d29f
CM
708 ret = create_pending_snapshots(trans, root->fs_info);
709 BUG_ON(ret);
710
2c90e5d6 711 WARN_ON(cur_trans != trans->transaction);
dc17ff8f 712
54aa1f4d
CM
713 ret = add_dirty_roots(trans, &root->fs_info->fs_roots_radix,
714 &dirty_fs_roots);
715 BUG_ON(ret);
716
79154b1b
CM
717 ret = btrfs_commit_tree_roots(trans, root);
718 BUG_ON(ret);
54aa1f4d 719
78fae27e 720 cur_trans = root->fs_info->running_transaction;
cee36a03 721 spin_lock(&root->fs_info->new_trans_lock);
78fae27e 722 root->fs_info->running_transaction = NULL;
cee36a03 723 spin_unlock(&root->fs_info->new_trans_lock);
4b52dff6
CM
724 btrfs_set_super_generation(&root->fs_info->super_copy,
725 cur_trans->transid);
726 btrfs_set_super_root(&root->fs_info->super_copy,
db94535d
CM
727 root->fs_info->tree_root->node->start);
728 btrfs_set_super_root_level(&root->fs_info->super_copy,
729 btrfs_header_level(root->fs_info->tree_root->node));
5f39d397 730
0b86a832
CM
731 btrfs_set_super_chunk_root(&root->fs_info->super_copy,
732 chunk_root->node->start);
733 btrfs_set_super_chunk_root_level(&root->fs_info->super_copy,
734 btrfs_header_level(chunk_root->node));
5f39d397
CM
735 write_extent_buffer(root->fs_info->sb_buffer,
736 &root->fs_info->super_copy, 0,
737 sizeof(root->fs_info->super_copy));
ccd467d6 738
4313b399 739 btrfs_copy_pinned(root, pinned_copy);
ccd467d6 740
78fae27e 741 mutex_unlock(&root->fs_info->trans_mutex);
8fd17795 742 mutex_unlock(&root->fs_info->fs_mutex);
79154b1b
CM
743 ret = btrfs_write_and_wait_transaction(trans, root);
744 BUG_ON(ret);
79154b1b 745 write_ctree_super(trans, root);
4313b399 746
8fd17795 747 mutex_lock(&root->fs_info->fs_mutex);
4313b399 748 btrfs_finish_extent_commit(trans, root, pinned_copy);
78fae27e 749 mutex_lock(&root->fs_info->trans_mutex);
4313b399
CM
750
751 kfree(pinned_copy);
752
2c90e5d6 753 cur_trans->commit_done = 1;
15ee9bc7 754 root->fs_info->last_trans_committed = cur_trans->transid;
2c90e5d6 755 wake_up(&cur_trans->commit_wait);
78fae27e 756 put_transaction(cur_trans);
79154b1b 757 put_transaction(cur_trans);
58176a96 758
facda1e7
CM
759 if (root->fs_info->closing)
760 list_splice_init(&root->fs_info->dead_roots, &dirty_fs_roots);
761 else
762 list_splice_init(&dirty_fs_roots, &root->fs_info->dead_roots);
58176a96 763
78fae27e 764 mutex_unlock(&root->fs_info->trans_mutex);
2c90e5d6 765 kmem_cache_free(btrfs_trans_handle_cachep, trans);
79154b1b 766
facda1e7
CM
767 if (root->fs_info->closing) {
768 mutex_unlock(&root->fs_info->fs_mutex);
769 drop_dirty_roots(root->fs_info->tree_root, &dirty_fs_roots);
770 mutex_lock(&root->fs_info->fs_mutex);
771 }
79154b1b
CM
772 return ret;
773}
774
e9d0b13b
CM
775int btrfs_clean_old_snapshots(struct btrfs_root *root)
776{
777 struct list_head dirty_roots;
778 INIT_LIST_HEAD(&dirty_roots);
779
780 mutex_lock(&root->fs_info->trans_mutex);
781 list_splice_init(&root->fs_info->dead_roots, &dirty_roots);
782 mutex_unlock(&root->fs_info->trans_mutex);
783
784 if (!list_empty(&dirty_roots)) {
785 drop_dirty_roots(root, &dirty_roots);
786 }
787 return 0;
788}
6da6abae
CM
789#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
790void btrfs_transaction_cleaner(void *p)
791#else
08607c1b 792void btrfs_transaction_cleaner(struct work_struct *work)
6da6abae 793#endif
08607c1b 794{
6da6abae
CM
795#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
796 struct btrfs_fs_info *fs_info = p;
797#else
08607c1b
CM
798 struct btrfs_fs_info *fs_info = container_of(work,
799 struct btrfs_fs_info,
800 trans_work.work);
801
6da6abae 802#endif
08607c1b
CM
803 struct btrfs_root *root = fs_info->tree_root;
804 struct btrfs_transaction *cur;
805 struct btrfs_trans_handle *trans;
806 unsigned long now;
807 unsigned long delay = HZ * 30;
808 int ret;
809
08607c1b
CM
810 mutex_lock(&root->fs_info->fs_mutex);
811 mutex_lock(&root->fs_info->trans_mutex);
812 cur = root->fs_info->running_transaction;
813 if (!cur) {
814 mutex_unlock(&root->fs_info->trans_mutex);
815 goto out;
816 }
817 now = get_seconds();
818 if (now < cur->start_time || now - cur->start_time < 30) {
819 mutex_unlock(&root->fs_info->trans_mutex);
820 delay = HZ * 5;
821 goto out;
822 }
823 mutex_unlock(&root->fs_info->trans_mutex);
6702ed49 824 btrfs_defrag_dirty_roots(root->fs_info);
08607c1b
CM
825 trans = btrfs_start_transaction(root, 1);
826 ret = btrfs_commit_transaction(trans, root);
827out:
828 mutex_unlock(&root->fs_info->fs_mutex);
e9d0b13b 829 btrfs_clean_old_snapshots(root);
08607c1b
CM
830 btrfs_transaction_queue_work(root, delay);
831}
832
833void btrfs_transaction_queue_work(struct btrfs_root *root, int delay)
834{
835 queue_delayed_work(trans_wq, &root->fs_info->trans_work, delay);
836}
837
838void btrfs_transaction_flush_work(struct btrfs_root *root)
839{
840 cancel_rearming_delayed_workqueue(trans_wq, &root->fs_info->trans_work);
841 flush_workqueue(trans_wq);
842}
843
844void __init btrfs_init_transaction_sys(void)
845{
ce9adaa5 846 trans_wq = create_workqueue("btrfs-transaction");
08607c1b
CM
847}
848
17636e03 849void btrfs_exit_transaction_sys(void)
08607c1b
CM
850{
851 destroy_workqueue(trans_wq);
852}
853