projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6
[deliverable/linux.git] / fs / btrfs / transaction.c
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
19 #include <linux/fs.h>
20 #include <linux/sched.h>
21 #include <linux/writeback.h>
22 #include <linux/pagemap.h>
23 #include <linux/blkdev.h>
24 #include "ctree.h"
25 #include "disk-io.h"
26 #include "transaction.h"
27 #include "locking.h"
28 #include "ref-cache.h"
29 #include "tree-log.h"
30
31 #define BTRFS_ROOT_TRANS_TAG 0
32
33 static noinline void put_transaction(struct btrfs_transaction *transaction)
34 {
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);
41 }
42 }
43
44 /*
45 * either allocate a new transaction or hop into the existing one
46 */
47 static noinline int join_transaction(struct btrfs_root *root)
48 {
49 struct btrfs_transaction *cur_trans;
50 cur_trans = root->fs_info->running_transaction;
51 if (!cur_trans) {
52 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep,
53 GFP_NOFS);
54 BUG_ON(!cur_trans);
55 root->fs_info->generation++;
56 root->fs_info->last_alloc = 0;
57 root->fs_info->last_data_alloc = 0;
58 cur_trans->num_writers = 1;
59 cur_trans->num_joined = 0;
60 cur_trans->transid = root->fs_info->generation;
61 init_waitqueue_head(&cur_trans->writer_wait);
62 init_waitqueue_head(&cur_trans->commit_wait);
63 cur_trans->in_commit = 0;
64 cur_trans->blocked = 0;
65 cur_trans->use_count = 1;
66 cur_trans->commit_done = 0;
67 cur_trans->start_time = get_seconds();
68
69 cur_trans->delayed_refs.root.rb_node = NULL;
70 cur_trans->delayed_refs.num_entries = 0;
71 cur_trans->delayed_refs.num_heads_ready = 0;
72 cur_trans->delayed_refs.num_heads = 0;
73 cur_trans->delayed_refs.flushing = 0;
74 cur_trans->delayed_refs.run_delayed_start = 0;
75 spin_lock_init(&cur_trans->delayed_refs.lock);
76
77 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
78 list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
79 extent_io_tree_init(&cur_trans->dirty_pages,
80 root->fs_info->btree_inode->i_mapping,
81 GFP_NOFS);
82 spin_lock(&root->fs_info->new_trans_lock);
83 root->fs_info->running_transaction = cur_trans;
84 spin_unlock(&root->fs_info->new_trans_lock);
85 } else {
86 cur_trans->num_writers++;
87 cur_trans->num_joined++;
88 }
89
90 return 0;
91 }
92
93 /*
94 * this does all the record keeping required to make sure that a reference
95 * counted root is properly recorded in a given transaction. This is required
96 * to make sure the old root from before we joined the transaction is deleted
97 * when the transaction commits
98 */
99 noinline int btrfs_record_root_in_trans(struct btrfs_root *root)
100 {
101 struct btrfs_dirty_root *dirty;
102 u64 running_trans_id = root->fs_info->running_transaction->transid;
103 if (root->ref_cows && root->last_trans < running_trans_id) {
104 WARN_ON(root == root->fs_info->extent_root);
105 if (root->root_item.refs != 0) {
106 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
107 (unsigned long)root->root_key.objectid,
108 BTRFS_ROOT_TRANS_TAG);
109
110 dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
111 BUG_ON(!dirty);
112 dirty->root = kmalloc(sizeof(*dirty->root), GFP_NOFS);
113 BUG_ON(!dirty->root);
114 dirty->latest_root = root;
115 INIT_LIST_HEAD(&dirty->list);
116
117 root->commit_root = btrfs_root_node(root);
118
119 memcpy(dirty->root, root, sizeof(*root));
120 spin_lock_init(&dirty->root->node_lock);
121 spin_lock_init(&dirty->root->list_lock);
122 mutex_init(&dirty->root->objectid_mutex);
123 mutex_init(&dirty->root->log_mutex);
124 INIT_LIST_HEAD(&dirty->root->dead_list);
125 dirty->root->node = root->commit_root;
126 dirty->root->commit_root = NULL;
127
128 spin_lock(&root->list_lock);
129 list_add(&dirty->root->dead_list, &root->dead_list);
130 spin_unlock(&root->list_lock);
131
132 root->dirty_root = dirty;
133 } else {
134 WARN_ON(1);
135 }
136 root->last_trans = running_trans_id;
137 }
138 return 0;
139 }
140
141 /* wait for commit against the current transaction to become unblocked
142 * when this is done, it is safe to start a new transaction, but the current
143 * transaction might not be fully on disk.
144 */
145 static void wait_current_trans(struct btrfs_root *root)
146 {
147 struct btrfs_transaction *cur_trans;
148
149 cur_trans = root->fs_info->running_transaction;
150 if (cur_trans && cur_trans->blocked) {
151 DEFINE_WAIT(wait);
152 cur_trans->use_count++;
153 while (1) {
154 prepare_to_wait(&root->fs_info->transaction_wait, &wait,
155 TASK_UNINTERRUPTIBLE);
156 if (cur_trans->blocked) {
157 mutex_unlock(&root->fs_info->trans_mutex);
158 schedule();
159 mutex_lock(&root->fs_info->trans_mutex);
160 finish_wait(&root->fs_info->transaction_wait,
161 &wait);
162 } else {
163 finish_wait(&root->fs_info->transaction_wait,
164 &wait);
165 break;
166 }
167 }
168 put_transaction(cur_trans);
169 }
170 }
171
172 static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
173 int num_blocks, int wait)
174 {
175 struct btrfs_trans_handle *h =
176 kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
177 int ret;
178
179 mutex_lock(&root->fs_info->trans_mutex);
180 if (!root->fs_info->log_root_recovering &&
181 ((wait == 1 && !root->fs_info->open_ioctl_trans) || wait == 2))
182 wait_current_trans(root);
183 ret = join_transaction(root);
184 BUG_ON(ret);
185
186 btrfs_record_root_in_trans(root);
187 h->transid = root->fs_info->running_transaction->transid;
188 h->transaction = root->fs_info->running_transaction;
189 h->blocks_reserved = num_blocks;
190 h->blocks_used = 0;
191 h->block_group = 0;
192 h->alloc_exclude_nr = 0;
193 h->alloc_exclude_start = 0;
194 h->delayed_ref_updates = 0;
195
196 root->fs_info->running_transaction->use_count++;
197 mutex_unlock(&root->fs_info->trans_mutex);
198 return h;
199 }
200
201 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
202 int num_blocks)
203 {
204 return start_transaction(root, num_blocks, 1);
205 }
206 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root,
207 int num_blocks)
208 {
209 return start_transaction(root, num_blocks, 0);
210 }
211
212 struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r,
213 int num_blocks)
214 {
215 return start_transaction(r, num_blocks, 2);
216 }
217
218 /* wait for a transaction commit to be fully complete */
219 static noinline int wait_for_commit(struct btrfs_root *root,
220 struct btrfs_transaction *commit)
221 {
222 DEFINE_WAIT(wait);
223 mutex_lock(&root->fs_info->trans_mutex);
224 while (!commit->commit_done) {
225 prepare_to_wait(&commit->commit_wait, &wait,
226 TASK_UNINTERRUPTIBLE);
227 if (commit->commit_done)
228 break;
229 mutex_unlock(&root->fs_info->trans_mutex);
230 schedule();
231 mutex_lock(&root->fs_info->trans_mutex);
232 }
233 mutex_unlock(&root->fs_info->trans_mutex);
234 finish_wait(&commit->commit_wait, &wait);
235 return 0;
236 }
237
238 /*
239 * rate limit against the drop_snapshot code. This helps to slow down new
240 * operations if the drop_snapshot code isn't able to keep up.
241 */
242 static void throttle_on_drops(struct btrfs_root *root)
243 {
244 struct btrfs_fs_info *info = root->fs_info;
245 int harder_count = 0;
246
247 harder:
248 if (atomic_read(&info->throttles)) {
249 DEFINE_WAIT(wait);
250 int thr;
251 thr = atomic_read(&info->throttle_gen);
252
253 do {
254 prepare_to_wait(&info->transaction_throttle,
255 &wait, TASK_UNINTERRUPTIBLE);
256 if (!atomic_read(&info->throttles)) {
257 finish_wait(&info->transaction_throttle, &wait);
258 break;
259 }
260 schedule();
261 finish_wait(&info->transaction_throttle, &wait);
262 } while (thr == atomic_read(&info->throttle_gen));
263 harder_count++;
264
265 if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 &&
266 harder_count < 2)
267 goto harder;
268
269 if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 &&
270 harder_count < 10)
271 goto harder;
272
273 if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 &&
274 harder_count < 20)
275 goto harder;
276 }
277 }
278
279 void btrfs_throttle(struct btrfs_root *root)
280 {
281 mutex_lock(&root->fs_info->trans_mutex);
282 if (!root->fs_info->open_ioctl_trans)
283 wait_current_trans(root);
284 mutex_unlock(&root->fs_info->trans_mutex);
285 throttle_on_drops(root);
286 }
287
288 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
289 struct btrfs_root *root, int throttle)
290 {
291 struct btrfs_transaction *cur_trans;
292 struct btrfs_fs_info *info = root->fs_info;
293 int count = 0;
294
295 while (count < 4) {
296 unsigned long cur = trans->delayed_ref_updates;
297 trans->delayed_ref_updates = 0;
298 if (cur &&
299 trans->transaction->delayed_refs.num_heads_ready > 64) {
300 trans->delayed_ref_updates = 0;
301
302 /*
303 * do a full flush if the transaction is trying
304 * to close
305 */
306 if (trans->transaction->delayed_refs.flushing)
307 cur = 0;
308 btrfs_run_delayed_refs(trans, root, cur);
309 } else {
310 break;
311 }
312 count++;
313 }
314
315 mutex_lock(&info->trans_mutex);
316 cur_trans = info->running_transaction;
317 WARN_ON(cur_trans != trans->transaction);
318 WARN_ON(cur_trans->num_writers < 1);
319 cur_trans->num_writers--;
320
321 if (waitqueue_active(&cur_trans->writer_wait))
322 wake_up(&cur_trans->writer_wait);
323 put_transaction(cur_trans);
324 mutex_unlock(&info->trans_mutex);
325 memset(trans, 0, sizeof(*trans));
326 kmem_cache_free(btrfs_trans_handle_cachep, trans);
327
328 if (throttle)
329 throttle_on_drops(root);
330
331 return 0;
332 }
333
334 int btrfs_end_transaction(struct btrfs_trans_handle *trans,
335 struct btrfs_root *root)
336 {
337 return __btrfs_end_transaction(trans, root, 0);
338 }
339
340 int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
341 struct btrfs_root *root)
342 {
343 return __btrfs_end_transaction(trans, root, 1);
344 }
345
346 /*
347 * when btree blocks are allocated, they have some corresponding bits set for
348 * them in one of two extent_io trees. This is used to make sure all of
349 * those extents are on disk for transaction or log commit
350 */
351 int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
352 struct extent_io_tree *dirty_pages)
353 {
354 int ret;
355 int err = 0;
356 int werr = 0;
357 struct page *page;
358 struct inode *btree_inode = root->fs_info->btree_inode;
359 u64 start = 0;
360 u64 end;
361 unsigned long index;
362
363 while (1) {
364 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
365 EXTENT_DIRTY);
366 if (ret)
367 break;
368 while (start <= end) {
369 cond_resched();
370
371 index = start >> PAGE_CACHE_SHIFT;
372 start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
373 page = find_get_page(btree_inode->i_mapping, index);
374 if (!page)
375 continue;
376
377 btree_lock_page_hook(page);
378 if (!page->mapping) {
379 unlock_page(page);
380 page_cache_release(page);
381 continue;
382 }
383
384 if (PageWriteback(page)) {
385 if (PageDirty(page))
386 wait_on_page_writeback(page);
387 else {
388 unlock_page(page);
389 page_cache_release(page);
390 continue;
391 }
392 }
393 err = write_one_page(page, 0);
394 if (err)
395 werr = err;
396 page_cache_release(page);
397 }
398 }
399 while (1) {
400 ret = find_first_extent_bit(dirty_pages, 0, &start, &end,
401 EXTENT_DIRTY);
402 if (ret)
403 break;
404
405 clear_extent_dirty(dirty_pages, start, end, GFP_NOFS);
406 while (start <= end) {
407 index = start >> PAGE_CACHE_SHIFT;
408 start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
409 page = find_get_page(btree_inode->i_mapping, index);
410 if (!page)
411 continue;
412 if (PageDirty(page)) {
413 btree_lock_page_hook(page);
414 wait_on_page_writeback(page);
415 err = write_one_page(page, 0);
416 if (err)
417 werr = err;
418 }
419 wait_on_page_writeback(page);
420 page_cache_release(page);
421 cond_resched();
422 }
423 }
424 if (err)
425 werr = err;
426 return werr;
427 }
428
429 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
430 struct btrfs_root *root)
431 {
432 if (!trans || !trans->transaction) {
433 struct inode *btree_inode;
434 btree_inode = root->fs_info->btree_inode;
435 return filemap_write_and_wait(btree_inode->i_mapping);
436 }
437 return btrfs_write_and_wait_marked_extents(root,
438 &trans->transaction->dirty_pages);
439 }
440
441 /*
442 * this is used to update the root pointer in the tree of tree roots.
443 *
444 * But, in the case of the extent allocation tree, updating the root
445 * pointer may allocate blocks which may change the root of the extent
446 * allocation tree.
447 *
448 * So, this loops and repeats and makes sure the cowonly root didn't
449 * change while the root pointer was being updated in the metadata.
450 */
451 static int update_cowonly_root(struct btrfs_trans_handle *trans,
452 struct btrfs_root *root)
453 {
454 int ret;
455 u64 old_root_bytenr;
456 struct btrfs_root *tree_root = root->fs_info->tree_root;
457
458 btrfs_write_dirty_block_groups(trans, root);
459
460 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
461 BUG_ON(ret);
462
463 while (1) {
464 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
465 if (old_root_bytenr == root->node->start)
466 break;
467 btrfs_set_root_bytenr(&root->root_item,
468 root->node->start);
469 btrfs_set_root_level(&root->root_item,
470 btrfs_header_level(root->node));
471 btrfs_set_root_generation(&root->root_item, trans->transid);
472
473 ret = btrfs_update_root(trans, tree_root,
474 &root->root_key,
475 &root->root_item);
476 BUG_ON(ret);
477 btrfs_write_dirty_block_groups(trans, root);
478
479 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
480 BUG_ON(ret);
481 }
482 return 0;
483 }
484
485 /*
486 * update all the cowonly tree roots on disk
487 */
488 int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans,
489 struct btrfs_root *root)
490 {
491 struct btrfs_fs_info *fs_info = root->fs_info;
492 struct list_head *next;
493 struct extent_buffer *eb;
494 int ret;
495
496 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
497 BUG_ON(ret);
498
499 eb = btrfs_lock_root_node(fs_info->tree_root);
500 btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
501 btrfs_tree_unlock(eb);
502 free_extent_buffer(eb);
503
504 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
505 BUG_ON(ret);
506
507 while (!list_empty(&fs_info->dirty_cowonly_roots)) {
508 next = fs_info->dirty_cowonly_roots.next;
509 list_del_init(next);
510 root = list_entry(next, struct btrfs_root, dirty_list);
511
512 update_cowonly_root(trans, root);
513
514 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
515 BUG_ON(ret);
516 }
517 return 0;
518 }
519
520 /*
521 * dead roots are old snapshots that need to be deleted. This allocates
522 * a dirty root struct and adds it into the list of dead roots that need to
523 * be deleted
524 */
525 int btrfs_add_dead_root(struct btrfs_root *root, struct btrfs_root *latest)
526 {
527 struct btrfs_dirty_root *dirty;
528
529 dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
530 if (!dirty)
531 return -ENOMEM;
532 dirty->root = root;
533 dirty->latest_root = latest;
534
535 mutex_lock(&root->fs_info->trans_mutex);
536 list_add(&dirty->list, &latest->fs_info->dead_roots);
537 mutex_unlock(&root->fs_info->trans_mutex);
538 return 0;
539 }
540
541 /*
542 * at transaction commit time we need to schedule the old roots for
543 * deletion via btrfs_drop_snapshot. This runs through all the
544 * reference counted roots that were modified in the current
545 * transaction and puts them into the drop list
546 */
547 static noinline int add_dirty_roots(struct btrfs_trans_handle *trans,
548 struct radix_tree_root *radix,
549 struct list_head *list)
550 {
551 struct btrfs_dirty_root *dirty;
552 struct btrfs_root *gang[8];
553 struct btrfs_root *root;
554 int i;
555 int ret;
556 int err = 0;
557 u32 refs;
558
559 while (1) {
560 ret = radix_tree_gang_lookup_tag(radix, (void **)gang, 0,
561 ARRAY_SIZE(gang),
562 BTRFS_ROOT_TRANS_TAG);
563 if (ret == 0)
564 break;
565 for (i = 0; i < ret; i++) {
566 root = gang[i];
567 radix_tree_tag_clear(radix,
568 (unsigned long)root->root_key.objectid,
569 BTRFS_ROOT_TRANS_TAG);
570
571 BUG_ON(!root->ref_tree);
572 dirty = root->dirty_root;
573
574 btrfs_free_log(trans, root);
575 btrfs_free_reloc_root(trans, root);
576
577 if (root->commit_root == root->node) {
578 WARN_ON(root->node->start !=
579 btrfs_root_bytenr(&root->root_item));
580
581 free_extent_buffer(root->commit_root);
582 root->commit_root = NULL;
583 root->dirty_root = NULL;
584
585 spin_lock(&root->list_lock);
586 list_del_init(&dirty->root->dead_list);
587 spin_unlock(&root->list_lock);
588
589 kfree(dirty->root);
590 kfree(dirty);
591
592 /* make sure to update the root on disk
593 * so we get any updates to the block used
594 * counts
595 */
596 err = btrfs_update_root(trans,
597 root->fs_info->tree_root,
598 &root->root_key,
599 &root->root_item);
600 continue;
601 }
602
603 memset(&root->root_item.drop_progress, 0,
604 sizeof(struct btrfs_disk_key));
605 root->root_item.drop_level = 0;
606 root->commit_root = NULL;
607 root->dirty_root = NULL;
608 root->root_key.offset = root->fs_info->generation;
609 btrfs_set_root_bytenr(&root->root_item,
610 root->node->start);
611 btrfs_set_root_level(&root->root_item,
612 btrfs_header_level(root->node));
613 btrfs_set_root_generation(&root->root_item,
614 root->root_key.offset);
615
616 err = btrfs_insert_root(trans, root->fs_info->tree_root,
617 &root->root_key,
618 &root->root_item);
619 if (err)
620 break;
621
622 refs = btrfs_root_refs(&dirty->root->root_item);
623 btrfs_set_root_refs(&dirty->root->root_item, refs - 1);
624 err = btrfs_update_root(trans, root->fs_info->tree_root,
625 &dirty->root->root_key,
626 &dirty->root->root_item);
627
628 BUG_ON(err);
629 if (refs == 1) {
630 list_add(&dirty->list, list);
631 } else {
632 WARN_ON(1);
633 free_extent_buffer(dirty->root->node);
634 kfree(dirty->root);
635 kfree(dirty);
636 }
637 }
638 }
639 return err;
640 }
641
642 /*
643 * defrag a given btree. If cacheonly == 1, this won't read from the disk,
644 * otherwise every leaf in the btree is read and defragged.
645 */
646 int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
647 {
648 struct btrfs_fs_info *info = root->fs_info;
649 int ret;
650 struct btrfs_trans_handle *trans;
651 unsigned long nr;
652
653 smp_mb();
654 if (root->defrag_running)
655 return 0;
656 trans = btrfs_start_transaction(root, 1);
657 while (1) {
658 root->defrag_running = 1;
659 ret = btrfs_defrag_leaves(trans, root, cacheonly);
660 nr = trans->blocks_used;
661 btrfs_end_transaction(trans, root);
662 btrfs_btree_balance_dirty(info->tree_root, nr);
663 cond_resched();
664
665 trans = btrfs_start_transaction(root, 1);
666 if (root->fs_info->closing || ret != -EAGAIN)
667 break;
668 }
669 root->defrag_running = 0;
670 smp_mb();
671 btrfs_end_transaction(trans, root);
672 return 0;
673 }
674
675 /*
676 * when dropping snapshots, we generate a ton of delayed refs, and it makes
677 * sense not to join the transaction while it is trying to flush the current
678 * queue of delayed refs out.
679 *
680 * This is used by the drop snapshot code only
681 */
682 static noinline int wait_transaction_pre_flush(struct btrfs_fs_info *info)
683 {
684 DEFINE_WAIT(wait);
685
686 mutex_lock(&info->trans_mutex);
687 while (info->running_transaction &&
688 info->running_transaction->delayed_refs.flushing) {
689 prepare_to_wait(&info->transaction_wait, &wait,
690 TASK_UNINTERRUPTIBLE);
691 mutex_unlock(&info->trans_mutex);
692 schedule();
693 mutex_lock(&info->trans_mutex);
694 finish_wait(&info->transaction_wait, &wait);
695 }
696 mutex_unlock(&info->trans_mutex);
697 return 0;
698 }
699
700 /*
701 * Given a list of roots that need to be deleted, call btrfs_drop_snapshot on
702 * all of them
703 */
704 static noinline int drop_dirty_roots(struct btrfs_root *tree_root,
705 struct list_head *list)
706 {
707 struct btrfs_dirty_root *dirty;
708 struct btrfs_trans_handle *trans;
709 unsigned long nr;
710 u64 num_bytes;
711 u64 bytes_used;
712 u64 max_useless;
713 int ret = 0;
714 int err;
715
716 while (!list_empty(list)) {
717 struct btrfs_root *root;
718
719 dirty = list_entry(list->prev, struct btrfs_dirty_root, list);
720 list_del_init(&dirty->list);
721
722 num_bytes = btrfs_root_used(&dirty->root->root_item);
723 root = dirty->latest_root;
724 atomic_inc(&root->fs_info->throttles);
725
726 while (1) {
727 /*
728 * we don't want to jump in and create a bunch of
729 * delayed refs if the transaction is starting to close
730 */
731 wait_transaction_pre_flush(tree_root->fs_info);
732 trans = btrfs_start_transaction(tree_root, 1);
733
734 /*
735 * we've joined a transaction, make sure it isn't
736 * closing right now
737 */
738 if (trans->transaction->delayed_refs.flushing) {
739 btrfs_end_transaction(trans, tree_root);
740 continue;
741 }
742
743 mutex_lock(&root->fs_info->drop_mutex);
744 ret = btrfs_drop_snapshot(trans, dirty->root);
745 if (ret != -EAGAIN)
746 break;
747 mutex_unlock(&root->fs_info->drop_mutex);
748
749 err = btrfs_update_root(trans,
750 tree_root,
751 &dirty->root->root_key,
752 &dirty->root->root_item);
753 if (err)
754 ret = err;
755 nr = trans->blocks_used;
756 ret = btrfs_end_transaction(trans, tree_root);
757 BUG_ON(ret);
758
759 btrfs_btree_balance_dirty(tree_root, nr);
760 cond_resched();
761 }
762 BUG_ON(ret);
763 atomic_dec(&root->fs_info->throttles);
764 wake_up(&root->fs_info->transaction_throttle);
765
766 num_bytes -= btrfs_root_used(&dirty->root->root_item);
767 bytes_used = btrfs_root_used(&root->root_item);
768 if (num_bytes) {
769 mutex_lock(&root->fs_info->trans_mutex);
770 btrfs_record_root_in_trans(root);
771 mutex_unlock(&root->fs_info->trans_mutex);
772 btrfs_set_root_used(&root->root_item,
773 bytes_used - num_bytes);
774 }
775
776 ret = btrfs_del_root(trans, tree_root, &dirty->root->root_key);
777 if (ret) {
778 BUG();
779 break;
780 }
781 mutex_unlock(&root->fs_info->drop_mutex);
782
783 spin_lock(&root->list_lock);
784 list_del_init(&dirty->root->dead_list);
785 if (!list_empty(&root->dead_list)) {
786 struct btrfs_root *oldest;
787 oldest = list_entry(root->dead_list.prev,
788 struct btrfs_root, dead_list);
789 max_useless = oldest->root_key.offset - 1;
790 } else {
791 max_useless = root->root_key.offset - 1;
792 }
793 spin_unlock(&root->list_lock);
794
795 nr = trans->blocks_used;
796 ret = btrfs_end_transaction(trans, tree_root);
797 BUG_ON(ret);
798
799 ret = btrfs_remove_leaf_refs(root, max_useless, 0);
800 BUG_ON(ret);
801
802 free_extent_buffer(dirty->root->node);
803 kfree(dirty->root);
804 kfree(dirty);
805
806 btrfs_btree_balance_dirty(tree_root, nr);
807 cond_resched();
808 }
809 return ret;
810 }
811
812 /*
813 * new snapshots need to be created at a very specific time in the
814 * transaction commit. This does the actual creation
815 */
816 static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
817 struct btrfs_fs_info *fs_info,
818 struct btrfs_pending_snapshot *pending)
819 {
820 struct btrfs_key key;
821 struct btrfs_root_item *new_root_item;
822 struct btrfs_root *tree_root = fs_info->tree_root;
823 struct btrfs_root *root = pending->root;
824 struct extent_buffer *tmp;
825 struct extent_buffer *old;
826 int ret;
827 u64 objectid;
828
829 new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
830 if (!new_root_item) {
831 ret = -ENOMEM;
832 goto fail;
833 }
834 ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid);
835 if (ret)
836 goto fail;
837
838 btrfs_record_root_in_trans(root);
839 btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
840 memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
841
842 key.objectid = objectid;
843 key.offset = trans->transid;
844 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
845
846 old = btrfs_lock_root_node(root);
847 btrfs_cow_block(trans, root, old, NULL, 0, &old);
848
849 btrfs_copy_root(trans, root, old, &tmp, objectid);
850 btrfs_tree_unlock(old);
851 free_extent_buffer(old);
852
853 btrfs_set_root_bytenr(new_root_item, tmp->start);
854 btrfs_set_root_level(new_root_item, btrfs_header_level(tmp));
855 btrfs_set_root_generation(new_root_item, trans->transid);
856 ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
857 new_root_item);
858 btrfs_tree_unlock(tmp);
859 free_extent_buffer(tmp);
860 if (ret)
861 goto fail;
862
863 key.offset = (u64)-1;
864 memcpy(&pending->root_key, &key, sizeof(key));
865 fail:
866 kfree(new_root_item);
867 return ret;
868 }
869
870 static noinline int finish_pending_snapshot(struct btrfs_fs_info *fs_info,
871 struct btrfs_pending_snapshot *pending)
872 {
873 int ret;
874 int namelen;
875 u64 index = 0;
876 struct btrfs_trans_handle *trans;
877 struct inode *parent_inode;
878 struct inode *inode;
879 struct btrfs_root *parent_root;
880
881 parent_inode = pending->dentry->d_parent->d_inode;
882 parent_root = BTRFS_I(parent_inode)->root;
883 trans = btrfs_join_transaction(parent_root, 1);
884
885 /*
886 * insert the directory item
887 */
888 namelen = strlen(pending->name);
889 ret = btrfs_set_inode_index(parent_inode, &index);
890 ret = btrfs_insert_dir_item(trans, parent_root,
891 pending->name, namelen,
892 parent_inode->i_ino,
893 &pending->root_key, BTRFS_FT_DIR, index);
894
895 if (ret)
896 goto fail;
897
898 btrfs_i_size_write(parent_inode, parent_inode->i_size + namelen * 2);
899 ret = btrfs_update_inode(trans, parent_root, parent_inode);
900 BUG_ON(ret);
901
902 /* add the backref first */
903 ret = btrfs_add_root_ref(trans, parent_root->fs_info->tree_root,
904 pending->root_key.objectid,
905 BTRFS_ROOT_BACKREF_KEY,
906 parent_root->root_key.objectid,
907 parent_inode->i_ino, index, pending->name,
908 namelen);
909
910 BUG_ON(ret);
911
912 /* now add the forward ref */
913 ret = btrfs_add_root_ref(trans, parent_root->fs_info->tree_root,
914 parent_root->root_key.objectid,
915 BTRFS_ROOT_REF_KEY,
916 pending->root_key.objectid,
917 parent_inode->i_ino, index, pending->name,
918 namelen);
919
920 inode = btrfs_lookup_dentry(parent_inode, pending->dentry);
921 d_instantiate(pending->dentry, inode);
922 fail:
923 btrfs_end_transaction(trans, fs_info->fs_root);
924 return ret;
925 }
926
927 /*
928 * create all the snapshots we've scheduled for creation
929 */
930 static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
931 struct btrfs_fs_info *fs_info)
932 {
933 struct btrfs_pending_snapshot *pending;
934 struct list_head *head = &trans->transaction->pending_snapshots;
935 int ret;
936
937 list_for_each_entry(pending, head, list) {
938 ret = create_pending_snapshot(trans, fs_info, pending);
939 BUG_ON(ret);
940 }
941 return 0;
942 }
943
944 static noinline int finish_pending_snapshots(struct btrfs_trans_handle *trans,
945 struct btrfs_fs_info *fs_info)
946 {
947 struct btrfs_pending_snapshot *pending;
948 struct list_head *head = &trans->transaction->pending_snapshots;
949 int ret;
950
951 while (!list_empty(head)) {
952 pending = list_entry(head->next,
953 struct btrfs_pending_snapshot, list);
954 ret = finish_pending_snapshot(fs_info, pending);
955 BUG_ON(ret);
956 list_del(&pending->list);
957 kfree(pending->name);
958 kfree(pending);
959 }
960 return 0;
961 }
962
963 int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
964 struct btrfs_root *root)
965 {
966 unsigned long joined = 0;
967 unsigned long timeout = 1;
968 struct btrfs_transaction *cur_trans;
969 struct btrfs_transaction *prev_trans = NULL;
970 struct btrfs_root *chunk_root = root->fs_info->chunk_root;
971 struct list_head dirty_fs_roots;
972 struct extent_io_tree *pinned_copy;
973 DEFINE_WAIT(wait);
974 int ret;
975 int should_grow = 0;
976 unsigned long now = get_seconds();
977
978 btrfs_run_ordered_operations(root, 0);
979
980 /* make a pass through all the delayed refs we have so far
981 * any runnings procs may add more while we are here
982 */
983 ret = btrfs_run_delayed_refs(trans, root, 0);
984 BUG_ON(ret);
985
986 cur_trans = trans->transaction;
987 /*
988 * set the flushing flag so procs in this transaction have to
989 * start sending their work down.
990 */
991 cur_trans->delayed_refs.flushing = 1;
992
993 ret = btrfs_run_delayed_refs(trans, root, 0);
994 BUG_ON(ret);
995
996 mutex_lock(&root->fs_info->trans_mutex);
997 INIT_LIST_HEAD(&dirty_fs_roots);
998 if (cur_trans->in_commit) {
999 cur_trans->use_count++;
1000 mutex_unlock(&root->fs_info->trans_mutex);
1001 btrfs_end_transaction(trans, root);
1002
1003 ret = wait_for_commit(root, cur_trans);
1004 BUG_ON(ret);
1005
1006 mutex_lock(&root->fs_info->trans_mutex);
1007 put_transaction(cur_trans);
1008 mutex_unlock(&root->fs_info->trans_mutex);
1009
1010 return 0;
1011 }
1012
1013 pinned_copy = kmalloc(sizeof(*pinned_copy), GFP_NOFS);
1014 if (!pinned_copy)
1015 return -ENOMEM;
1016
1017 extent_io_tree_init(pinned_copy,
1018 root->fs_info->btree_inode->i_mapping, GFP_NOFS);
1019
1020 trans->transaction->in_commit = 1;
1021 trans->transaction->blocked = 1;
1022 if (cur_trans->list.prev != &root->fs_info->trans_list) {
1023 prev_trans = list_entry(cur_trans->list.prev,
1024 struct btrfs_transaction, list);
1025 if (!prev_trans->commit_done) {
1026 prev_trans->use_count++;
1027 mutex_unlock(&root->fs_info->trans_mutex);
1028
1029 wait_for_commit(root, prev_trans);
1030
1031 mutex_lock(&root->fs_info->trans_mutex);
1032 put_transaction(prev_trans);
1033 }
1034 }
1035
1036 if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
1037 should_grow = 1;
1038
1039 do {
1040 int snap_pending = 0;
1041 joined = cur_trans->num_joined;
1042 if (!list_empty(&trans->transaction->pending_snapshots))
1043 snap_pending = 1;
1044
1045 WARN_ON(cur_trans != trans->transaction);
1046 prepare_to_wait(&cur_trans->writer_wait, &wait,
1047 TASK_UNINTERRUPTIBLE);
1048
1049 if (cur_trans->num_writers > 1)
1050 timeout = MAX_SCHEDULE_TIMEOUT;
1051 else if (should_grow)
1052 timeout = 1;
1053
1054 mutex_unlock(&root->fs_info->trans_mutex);
1055
1056 if (snap_pending) {
1057 ret = btrfs_wait_ordered_extents(root, 1);
1058 BUG_ON(ret);
1059 }
1060
1061 /*
1062 * rename don't use btrfs_join_transaction, so, once we
1063 * set the transaction to blocked above, we aren't going
1064 * to get any new ordered operations. We can safely run
1065 * it here and no for sure that nothing new will be added
1066 * to the list
1067 */
1068 btrfs_run_ordered_operations(root, 1);
1069
1070 smp_mb();
1071 if (cur_trans->num_writers > 1 || should_grow)
1072 schedule_timeout(timeout);
1073
1074 mutex_lock(&root->fs_info->trans_mutex);
1075 finish_wait(&cur_trans->writer_wait, &wait);
1076 } while (cur_trans->num_writers > 1 ||
1077 (should_grow && cur_trans->num_joined != joined));
1078
1079 ret = create_pending_snapshots(trans, root->fs_info);
1080 BUG_ON(ret);
1081
1082 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1083 BUG_ON(ret);
1084
1085 WARN_ON(cur_trans != trans->transaction);
1086
1087 /* btrfs_commit_tree_roots is responsible for getting the
1088 * various roots consistent with each other. Every pointer
1089 * in the tree of tree roots has to point to the most up to date
1090 * root for every subvolume and other tree. So, we have to keep
1091 * the tree logging code from jumping in and changing any
1092 * of the trees.
1093 *
1094 * At this point in the commit, there can't be any tree-log
1095 * writers, but a little lower down we drop the trans mutex
1096 * and let new people in. By holding the tree_log_mutex
1097 * from now until after the super is written, we avoid races
1098 * with the tree-log code.
1099 */
1100 mutex_lock(&root->fs_info->tree_log_mutex);
1101 /*
1102 * keep tree reloc code from adding new reloc trees
1103 */
1104 mutex_lock(&root->fs_info->tree_reloc_mutex);
1105
1106
1107 ret = add_dirty_roots(trans, &root->fs_info->fs_roots_radix,
1108 &dirty_fs_roots);
1109 BUG_ON(ret);
1110
1111 /* add_dirty_roots gets rid of all the tree log roots, it is now
1112 * safe to free the root of tree log roots
1113 */
1114 btrfs_free_log_root_tree(trans, root->fs_info);
1115
1116 ret = btrfs_commit_tree_roots(trans, root);
1117 BUG_ON(ret);
1118
1119 cur_trans = root->fs_info->running_transaction;
1120 spin_lock(&root->fs_info->new_trans_lock);
1121 root->fs_info->running_transaction = NULL;
1122 spin_unlock(&root->fs_info->new_trans_lock);
1123 btrfs_set_super_generation(&root->fs_info->super_copy,
1124 cur_trans->transid);
1125 btrfs_set_super_root(&root->fs_info->super_copy,
1126 root->fs_info->tree_root->node->start);
1127 btrfs_set_super_root_level(&root->fs_info->super_copy,
1128 btrfs_header_level(root->fs_info->tree_root->node));
1129
1130 btrfs_set_super_chunk_root(&root->fs_info->super_copy,
1131 chunk_root->node->start);
1132 btrfs_set_super_chunk_root_level(&root->fs_info->super_copy,
1133 btrfs_header_level(chunk_root->node));
1134 btrfs_set_super_chunk_root_generation(&root->fs_info->super_copy,
1135 btrfs_header_generation(chunk_root->node));
1136
1137 if (!root->fs_info->log_root_recovering) {
1138 btrfs_set_super_log_root(&root->fs_info->super_copy, 0);
1139 btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0);
1140 }
1141
1142 memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
1143 sizeof(root->fs_info->super_copy));
1144
1145 btrfs_copy_pinned(root, pinned_copy);
1146
1147 trans->transaction->blocked = 0;
1148
1149 wake_up(&root->fs_info->transaction_throttle);
1150 wake_up(&root->fs_info->transaction_wait);
1151
1152 mutex_unlock(&root->fs_info->trans_mutex);
1153 ret = btrfs_write_and_wait_transaction(trans, root);
1154 BUG_ON(ret);
1155 write_ctree_super(trans, root, 0);
1156
1157 /*
1158 * the super is written, we can safely allow the tree-loggers
1159 * to go about their business
1160 */
1161 mutex_unlock(&root->fs_info->tree_log_mutex);
1162
1163 btrfs_finish_extent_commit(trans, root, pinned_copy);
1164 kfree(pinned_copy);
1165
1166 btrfs_drop_dead_reloc_roots(root);
1167 mutex_unlock(&root->fs_info->tree_reloc_mutex);
1168
1169 /* do the directory inserts of any pending snapshot creations */
1170 finish_pending_snapshots(trans, root->fs_info);
1171
1172 mutex_lock(&root->fs_info->trans_mutex);
1173
1174 cur_trans->commit_done = 1;
1175
1176 root->fs_info->last_trans_committed = cur_trans->transid;
1177 wake_up(&cur_trans->commit_wait);
1178
1179 put_transaction(cur_trans);
1180 put_transaction(cur_trans);
1181
1182 list_splice_init(&dirty_fs_roots, &root->fs_info->dead_roots);
1183 if (root->fs_info->closing)
1184 list_splice_init(&root->fs_info->dead_roots, &dirty_fs_roots);
1185
1186 mutex_unlock(&root->fs_info->trans_mutex);
1187
1188 kmem_cache_free(btrfs_trans_handle_cachep, trans);
1189
1190 if (root->fs_info->closing)
1191 drop_dirty_roots(root->fs_info->tree_root, &dirty_fs_roots);
1192 return ret;
1193 }
1194
1195 /*
1196 * interface function to delete all the snapshots we have scheduled for deletion
1197 */
1198 int btrfs_clean_old_snapshots(struct btrfs_root *root)
1199 {
1200 struct list_head dirty_roots;
1201 INIT_LIST_HEAD(&dirty_roots);
1202 again:
1203 mutex_lock(&root->fs_info->trans_mutex);
1204 list_splice_init(&root->fs_info->dead_roots, &dirty_roots);
1205 mutex_unlock(&root->fs_info->trans_mutex);
1206
1207 if (!list_empty(&dirty_roots)) {
1208 drop_dirty_roots(root, &dirty_roots);
1209 goto again;
1210 }
1211 return 0;
1212 }
Linux kernel - Deliverables
This page took 0.074884 seconds and 5 git commands to generate.