1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2007 Oracle. All rights reserved.
7 #include <linux/slab.h>
8 #include <linux/sched.h>
9 #include <linux/writeback.h>
10 #include <linux/pagemap.h>
11 #include <linux/blkdev.h>
12 #include <linux/uuid.h>
15 #include "transaction.h"
18 #include "inode-map.h"
20 #include "dev-replace.h"
23 #define BTRFS_ROOT_TRANS_TAG 0
25 static const unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = {
26 [TRANS_STATE_RUNNING] = 0U,
27 [TRANS_STATE_BLOCKED] = __TRANS_START,
28 [TRANS_STATE_COMMIT_START] = (__TRANS_START | __TRANS_ATTACH),
29 [TRANS_STATE_COMMIT_DOING] = (__TRANS_START |
32 [TRANS_STATE_UNBLOCKED] = (__TRANS_START |
36 [TRANS_STATE_COMPLETED] = (__TRANS_START |
42 void btrfs_put_transaction(struct btrfs_transaction *transaction)
44 WARN_ON(refcount_read(&transaction->use_count) == 0);
45 if (refcount_dec_and_test(&transaction->use_count)) {
46 BUG_ON(!list_empty(&transaction->list));
47 WARN_ON(!RB_EMPTY_ROOT(
48 &transaction->delayed_refs.href_root.rb_root));
49 if (transaction->delayed_refs.pending_csums)
50 btrfs_err(transaction->fs_info,
51 "pending csums is %llu",
52 transaction->delayed_refs.pending_csums);
54 * If any block groups are found in ->deleted_bgs then it's
55 * because the transaction was aborted and a commit did not
56 * happen (things failed before writing the new superblock
57 * and calling btrfs_finish_extent_commit()), so we can not
58 * discard the physical locations of the block groups.
60 while (!list_empty(&transaction->deleted_bgs)) {
61 struct btrfs_block_group_cache *cache;
63 cache = list_first_entry(&transaction->deleted_bgs,
64 struct btrfs_block_group_cache,
66 list_del_init(&cache->bg_list);
67 btrfs_put_block_group_trimming(cache);
68 btrfs_put_block_group(cache);
70 WARN_ON(!list_empty(&transaction->dev_update_list));
75 static noinline void switch_commit_roots(struct btrfs_transaction *trans)
77 struct btrfs_fs_info *fs_info = trans->fs_info;
78 struct btrfs_root *root, *tmp;
80 down_write(&fs_info->commit_root_sem);
81 list_for_each_entry_safe(root, tmp, &trans->switch_commits,
83 list_del_init(&root->dirty_list);
84 free_extent_buffer(root->commit_root);
85 root->commit_root = btrfs_root_node(root);
86 if (is_fstree(root->root_key.objectid))
87 btrfs_unpin_free_ino(root);
88 extent_io_tree_release(&root->dirty_log_pages);
89 btrfs_qgroup_clean_swapped_blocks(root);
92 /* We can free old roots now. */
93 spin_lock(&trans->dropped_roots_lock);
94 while (!list_empty(&trans->dropped_roots)) {
95 root = list_first_entry(&trans->dropped_roots,
96 struct btrfs_root, root_list);
97 list_del_init(&root->root_list);
98 spin_unlock(&trans->dropped_roots_lock);
99 btrfs_drop_and_free_fs_root(fs_info, root);
100 spin_lock(&trans->dropped_roots_lock);
102 spin_unlock(&trans->dropped_roots_lock);
103 up_write(&fs_info->commit_root_sem);
106 static inline void extwriter_counter_inc(struct btrfs_transaction *trans,
109 if (type & TRANS_EXTWRITERS)
110 atomic_inc(&trans->num_extwriters);
113 static inline void extwriter_counter_dec(struct btrfs_transaction *trans,
116 if (type & TRANS_EXTWRITERS)
117 atomic_dec(&trans->num_extwriters);
120 static inline void extwriter_counter_init(struct btrfs_transaction *trans,
123 atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0));
126 static inline int extwriter_counter_read(struct btrfs_transaction *trans)
128 return atomic_read(&trans->num_extwriters);
132 * either allocate a new transaction or hop into the existing one
134 static noinline int join_transaction(struct btrfs_fs_info *fs_info,
137 struct btrfs_transaction *cur_trans;
139 spin_lock(&fs_info->trans_lock);
141 /* The file system has been taken offline. No new transactions. */
142 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
143 spin_unlock(&fs_info->trans_lock);
147 cur_trans = fs_info->running_transaction;
149 if (cur_trans->aborted) {
150 spin_unlock(&fs_info->trans_lock);
151 return cur_trans->aborted;
153 if (btrfs_blocked_trans_types[cur_trans->state] & type) {
154 spin_unlock(&fs_info->trans_lock);
157 refcount_inc(&cur_trans->use_count);
158 atomic_inc(&cur_trans->num_writers);
159 extwriter_counter_inc(cur_trans, type);
160 spin_unlock(&fs_info->trans_lock);
163 spin_unlock(&fs_info->trans_lock);
166 * If we are ATTACH, we just want to catch the current transaction,
167 * and commit it. If there is no transaction, just return ENOENT.
169 if (type == TRANS_ATTACH)
173 * JOIN_NOLOCK only happens during the transaction commit, so
174 * it is impossible that ->running_transaction is NULL
176 BUG_ON(type == TRANS_JOIN_NOLOCK);
178 cur_trans = kmalloc(sizeof(*cur_trans), GFP_NOFS);
182 spin_lock(&fs_info->trans_lock);
183 if (fs_info->running_transaction) {
185 * someone started a transaction after we unlocked. Make sure
186 * to redo the checks above
190 } else if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
191 spin_unlock(&fs_info->trans_lock);
196 cur_trans->fs_info = fs_info;
197 atomic_set(&cur_trans->num_writers, 1);
198 extwriter_counter_init(cur_trans, type);
199 init_waitqueue_head(&cur_trans->writer_wait);
200 init_waitqueue_head(&cur_trans->commit_wait);
201 cur_trans->state = TRANS_STATE_RUNNING;
203 * One for this trans handle, one so it will live on until we
204 * commit the transaction.
206 refcount_set(&cur_trans->use_count, 2);
207 cur_trans->flags = 0;
208 cur_trans->start_time = ktime_get_seconds();
210 memset(&cur_trans->delayed_refs, 0, sizeof(cur_trans->delayed_refs));
212 cur_trans->delayed_refs.href_root = RB_ROOT_CACHED;
213 cur_trans->delayed_refs.dirty_extent_root = RB_ROOT;
214 atomic_set(&cur_trans->delayed_refs.num_entries, 0);
217 * although the tree mod log is per file system and not per transaction,
218 * the log must never go across transaction boundaries.
221 if (!list_empty(&fs_info->tree_mod_seq_list))
222 WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when creating a fresh transaction\n");
223 if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log))
224 WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when creating a fresh transaction\n");
225 atomic64_set(&fs_info->tree_mod_seq, 0);
227 spin_lock_init(&cur_trans->delayed_refs.lock);
229 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
230 INIT_LIST_HEAD(&cur_trans->dev_update_list);
231 INIT_LIST_HEAD(&cur_trans->switch_commits);
232 INIT_LIST_HEAD(&cur_trans->dirty_bgs);
233 INIT_LIST_HEAD(&cur_trans->io_bgs);
234 INIT_LIST_HEAD(&cur_trans->dropped_roots);
235 mutex_init(&cur_trans->cache_write_mutex);
236 cur_trans->num_dirty_bgs = 0;
237 spin_lock_init(&cur_trans->dirty_bgs_lock);
238 INIT_LIST_HEAD(&cur_trans->deleted_bgs);
239 spin_lock_init(&cur_trans->dropped_roots_lock);
240 list_add_tail(&cur_trans->list, &fs_info->trans_list);
241 extent_io_tree_init(fs_info, &cur_trans->dirty_pages,
242 IO_TREE_TRANS_DIRTY_PAGES, fs_info->btree_inode);
243 fs_info->generation++;
244 cur_trans->transid = fs_info->generation;
245 fs_info->running_transaction = cur_trans;
246 cur_trans->aborted = 0;
247 spin_unlock(&fs_info->trans_lock);
253 * this does all the record keeping required to make sure that a reference
254 * counted root is properly recorded in a given transaction. This is required
255 * to make sure the old root from before we joined the transaction is deleted
256 * when the transaction commits
258 static int record_root_in_trans(struct btrfs_trans_handle *trans,
259 struct btrfs_root *root,
262 struct btrfs_fs_info *fs_info = root->fs_info;
264 if ((test_bit(BTRFS_ROOT_REF_COWS, &root->state) &&
265 root->last_trans < trans->transid) || force) {
266 WARN_ON(root == fs_info->extent_root);
267 WARN_ON(!force && root->commit_root != root->node);
270 * see below for IN_TRANS_SETUP usage rules
271 * we have the reloc mutex held now, so there
272 * is only one writer in this function
274 set_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state);
276 /* make sure readers find IN_TRANS_SETUP before
277 * they find our root->last_trans update
281 spin_lock(&fs_info->fs_roots_radix_lock);
282 if (root->last_trans == trans->transid && !force) {
283 spin_unlock(&fs_info->fs_roots_radix_lock);
286 radix_tree_tag_set(&fs_info->fs_roots_radix,
287 (unsigned long)root->root_key.objectid,
288 BTRFS_ROOT_TRANS_TAG);
289 spin_unlock(&fs_info->fs_roots_radix_lock);
290 root->last_trans = trans->transid;
292 /* this is pretty tricky. We don't want to
293 * take the relocation lock in btrfs_record_root_in_trans
294 * unless we're really doing the first setup for this root in
297 * Normally we'd use root->last_trans as a flag to decide
298 * if we want to take the expensive mutex.
300 * But, we have to set root->last_trans before we
301 * init the relocation root, otherwise, we trip over warnings
302 * in ctree.c. The solution used here is to flag ourselves
303 * with root IN_TRANS_SETUP. When this is 1, we're still
304 * fixing up the reloc trees and everyone must wait.
306 * When this is zero, they can trust root->last_trans and fly
307 * through btrfs_record_root_in_trans without having to take the
308 * lock. smp_wmb() makes sure that all the writes above are
309 * done before we pop in the zero below
311 btrfs_init_reloc_root(trans, root);
312 smp_mb__before_atomic();
313 clear_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state);
319 void btrfs_add_dropped_root(struct btrfs_trans_handle *trans,
320 struct btrfs_root *root)
322 struct btrfs_fs_info *fs_info = root->fs_info;
323 struct btrfs_transaction *cur_trans = trans->transaction;
325 /* Add ourselves to the transaction dropped list */
326 spin_lock(&cur_trans->dropped_roots_lock);
327 list_add_tail(&root->root_list, &cur_trans->dropped_roots);
328 spin_unlock(&cur_trans->dropped_roots_lock);
330 /* Make sure we don't try to update the root at commit time */
331 spin_lock(&fs_info->fs_roots_radix_lock);
332 radix_tree_tag_clear(&fs_info->fs_roots_radix,
333 (unsigned long)root->root_key.objectid,
334 BTRFS_ROOT_TRANS_TAG);
335 spin_unlock(&fs_info->fs_roots_radix_lock);
338 int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
339 struct btrfs_root *root)
341 struct btrfs_fs_info *fs_info = root->fs_info;
343 if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))
347 * see record_root_in_trans for comments about IN_TRANS_SETUP usage
351 if (root->last_trans == trans->transid &&
352 !test_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state))
355 mutex_lock(&fs_info->reloc_mutex);
356 record_root_in_trans(trans, root, 0);
357 mutex_unlock(&fs_info->reloc_mutex);
362 static inline int is_transaction_blocked(struct btrfs_transaction *trans)
364 return (trans->state >= TRANS_STATE_BLOCKED &&
365 trans->state < TRANS_STATE_UNBLOCKED &&
369 /* wait for commit against the current transaction to become unblocked
370 * when this is done, it is safe to start a new transaction, but the current
371 * transaction might not be fully on disk.
373 static void wait_current_trans(struct btrfs_fs_info *fs_info)
375 struct btrfs_transaction *cur_trans;
377 spin_lock(&fs_info->trans_lock);
378 cur_trans = fs_info->running_transaction;
379 if (cur_trans && is_transaction_blocked(cur_trans)) {
380 refcount_inc(&cur_trans->use_count);
381 spin_unlock(&fs_info->trans_lock);
383 wait_event(fs_info->transaction_wait,
384 cur_trans->state >= TRANS_STATE_UNBLOCKED ||
386 btrfs_put_transaction(cur_trans);
388 spin_unlock(&fs_info->trans_lock);
392 static int may_wait_transaction(struct btrfs_fs_info *fs_info, int type)
394 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))
397 if (type == TRANS_START)
403 static inline bool need_reserve_reloc_root(struct btrfs_root *root)
405 struct btrfs_fs_info *fs_info = root->fs_info;
407 if (!fs_info->reloc_ctl ||
408 !test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
409 root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
416 static struct btrfs_trans_handle *
417 start_transaction(struct btrfs_root *root, unsigned int num_items,
418 unsigned int type, enum btrfs_reserve_flush_enum flush,
419 bool enforce_qgroups)
421 struct btrfs_fs_info *fs_info = root->fs_info;
422 struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;
423 struct btrfs_trans_handle *h;
424 struct btrfs_transaction *cur_trans;
426 u64 qgroup_reserved = 0;
427 bool reloc_reserved = false;
430 /* Send isn't supposed to start transactions. */
431 ASSERT(current->journal_info != BTRFS_SEND_TRANS_STUB);
433 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
434 return ERR_PTR(-EROFS);
436 if (current->journal_info) {
437 WARN_ON(type & TRANS_EXTWRITERS);
438 h = current->journal_info;
439 refcount_inc(&h->use_count);
440 WARN_ON(refcount_read(&h->use_count) > 2);
441 h->orig_rsv = h->block_rsv;
447 * Do the reservation before we join the transaction so we can do all
448 * the appropriate flushing if need be.
450 if (num_items && root != fs_info->chunk_root) {
451 struct btrfs_block_rsv *rsv = &fs_info->trans_block_rsv;
452 u64 delayed_refs_bytes = 0;
454 qgroup_reserved = num_items * fs_info->nodesize;
455 ret = btrfs_qgroup_reserve_meta_pertrans(root, qgroup_reserved,
461 * We want to reserve all the bytes we may need all at once, so
462 * we only do 1 enospc flushing cycle per transaction start. We
463 * accomplish this by simply assuming we'll do 2 x num_items
464 * worth of delayed refs updates in this trans handle, and
465 * refill that amount for whatever is missing in the reserve.
467 num_bytes = btrfs_calc_trans_metadata_size(fs_info, num_items);
468 if (delayed_refs_rsv->full == 0) {
469 delayed_refs_bytes = num_bytes;
474 * Do the reservation for the relocation root creation
476 if (need_reserve_reloc_root(root)) {
477 num_bytes += fs_info->nodesize;
478 reloc_reserved = true;
481 ret = btrfs_block_rsv_add(root, rsv, num_bytes, flush);
484 if (delayed_refs_bytes) {
485 btrfs_migrate_to_delayed_refs_rsv(fs_info, rsv,
487 num_bytes -= delayed_refs_bytes;
489 } else if (num_items == 0 && flush == BTRFS_RESERVE_FLUSH_ALL &&
490 !delayed_refs_rsv->full) {
492 * Some people call with btrfs_start_transaction(root, 0)
493 * because they can be throttled, but have some other mechanism
494 * for reserving space. We still want these guys to refill the
495 * delayed block_rsv so just add 1 items worth of reservation
498 ret = btrfs_delayed_refs_rsv_refill(fs_info, flush);
503 h = kmem_cache_zalloc(btrfs_trans_handle_cachep, GFP_NOFS);
510 * If we are JOIN_NOLOCK we're already committing a transaction and
511 * waiting on this guy, so we don't need to do the sb_start_intwrite
512 * because we're already holding a ref. We need this because we could
513 * have raced in and did an fsync() on a file which can kick a commit
514 * and then we deadlock with somebody doing a freeze.
516 * If we are ATTACH, it means we just want to catch the current
517 * transaction and commit it, so we needn't do sb_start_intwrite().
519 if (type & __TRANS_FREEZABLE)
520 sb_start_intwrite(fs_info->sb);
522 if (may_wait_transaction(fs_info, type))
523 wait_current_trans(fs_info);
526 ret = join_transaction(fs_info, type);
528 wait_current_trans(fs_info);
529 if (unlikely(type == TRANS_ATTACH))
532 } while (ret == -EBUSY);
537 cur_trans = fs_info->running_transaction;
539 h->transid = cur_trans->transid;
540 h->transaction = cur_trans;
542 refcount_set(&h->use_count, 1);
543 h->fs_info = root->fs_info;
546 h->can_flush_pending_bgs = true;
547 INIT_LIST_HEAD(&h->new_bgs);
550 if (cur_trans->state >= TRANS_STATE_BLOCKED &&
551 may_wait_transaction(fs_info, type)) {
552 current->journal_info = h;
553 btrfs_commit_transaction(h);
558 trace_btrfs_space_reservation(fs_info, "transaction",
559 h->transid, num_bytes, 1);
560 h->block_rsv = &fs_info->trans_block_rsv;
561 h->bytes_reserved = num_bytes;
562 h->reloc_reserved = reloc_reserved;
566 btrfs_record_root_in_trans(h, root);
568 if (!current->journal_info)
569 current->journal_info = h;
573 if (type & __TRANS_FREEZABLE)
574 sb_end_intwrite(fs_info->sb);
575 kmem_cache_free(btrfs_trans_handle_cachep, h);
578 btrfs_block_rsv_release(fs_info, &fs_info->trans_block_rsv,
581 btrfs_qgroup_free_meta_pertrans(root, qgroup_reserved);
585 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
586 unsigned int num_items)
588 return start_transaction(root, num_items, TRANS_START,
589 BTRFS_RESERVE_FLUSH_ALL, true);
592 struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv(
593 struct btrfs_root *root,
594 unsigned int num_items,
597 struct btrfs_fs_info *fs_info = root->fs_info;
598 struct btrfs_trans_handle *trans;
603 * We have two callers: unlink and block group removal. The
604 * former should succeed even if we will temporarily exceed
605 * quota and the latter operates on the extent root so
606 * qgroup enforcement is ignored anyway.
608 trans = start_transaction(root, num_items, TRANS_START,
609 BTRFS_RESERVE_FLUSH_ALL, false);
610 if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC)
613 trans = btrfs_start_transaction(root, 0);
617 num_bytes = btrfs_calc_trans_metadata_size(fs_info, num_items);
618 ret = btrfs_cond_migrate_bytes(fs_info, &fs_info->trans_block_rsv,
619 num_bytes, min_factor);
621 btrfs_end_transaction(trans);
625 trans->block_rsv = &fs_info->trans_block_rsv;
626 trans->bytes_reserved = num_bytes;
627 trace_btrfs_space_reservation(fs_info, "transaction",
628 trans->transid, num_bytes, 1);
633 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
635 return start_transaction(root, 0, TRANS_JOIN, BTRFS_RESERVE_NO_FLUSH,
639 struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
641 return start_transaction(root, 0, TRANS_JOIN_NOLOCK,
642 BTRFS_RESERVE_NO_FLUSH, true);
646 * btrfs_attach_transaction() - catch the running transaction
648 * It is used when we want to commit the current the transaction, but
649 * don't want to start a new one.
651 * Note: If this function return -ENOENT, it just means there is no
652 * running transaction. But it is possible that the inactive transaction
653 * is still in the memory, not fully on disk. If you hope there is no
654 * inactive transaction in the fs when -ENOENT is returned, you should
656 * btrfs_attach_transaction_barrier()
658 struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root)
660 return start_transaction(root, 0, TRANS_ATTACH,
661 BTRFS_RESERVE_NO_FLUSH, true);
665 * btrfs_attach_transaction_barrier() - catch the running transaction
667 * It is similar to the above function, the difference is this one
668 * will wait for all the inactive transactions until they fully
671 struct btrfs_trans_handle *
672 btrfs_attach_transaction_barrier(struct btrfs_root *root)
674 struct btrfs_trans_handle *trans;
676 trans = start_transaction(root, 0, TRANS_ATTACH,
677 BTRFS_RESERVE_NO_FLUSH, true);
678 if (trans == ERR_PTR(-ENOENT))
679 btrfs_wait_for_commit(root->fs_info, 0);
684 /* wait for a transaction commit to be fully complete */
685 static noinline void wait_for_commit(struct btrfs_transaction *commit)
687 wait_event(commit->commit_wait, commit->state == TRANS_STATE_COMPLETED);
690 int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid)
692 struct btrfs_transaction *cur_trans = NULL, *t;
696 if (transid <= fs_info->last_trans_committed)
699 /* find specified transaction */
700 spin_lock(&fs_info->trans_lock);
701 list_for_each_entry(t, &fs_info->trans_list, list) {
702 if (t->transid == transid) {
704 refcount_inc(&cur_trans->use_count);
708 if (t->transid > transid) {
713 spin_unlock(&fs_info->trans_lock);
716 * The specified transaction doesn't exist, or we
717 * raced with btrfs_commit_transaction
720 if (transid > fs_info->last_trans_committed)
725 /* find newest transaction that is committing | committed */
726 spin_lock(&fs_info->trans_lock);
727 list_for_each_entry_reverse(t, &fs_info->trans_list,
729 if (t->state >= TRANS_STATE_COMMIT_START) {
730 if (t->state == TRANS_STATE_COMPLETED)
733 refcount_inc(&cur_trans->use_count);
737 spin_unlock(&fs_info->trans_lock);
739 goto out; /* nothing committing|committed */
742 wait_for_commit(cur_trans);
743 btrfs_put_transaction(cur_trans);
748 void btrfs_throttle(struct btrfs_fs_info *fs_info)
750 wait_current_trans(fs_info);
753 static int should_end_transaction(struct btrfs_trans_handle *trans)
755 struct btrfs_fs_info *fs_info = trans->fs_info;
757 if (btrfs_check_space_for_delayed_refs(fs_info))
760 return !!btrfs_block_rsv_check(&fs_info->global_block_rsv, 5);
763 int btrfs_should_end_transaction(struct btrfs_trans_handle *trans)
765 struct btrfs_transaction *cur_trans = trans->transaction;
768 if (cur_trans->state >= TRANS_STATE_BLOCKED ||
769 cur_trans->delayed_refs.flushing)
772 return should_end_transaction(trans);
775 static void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans)
778 struct btrfs_fs_info *fs_info = trans->fs_info;
780 if (!trans->block_rsv) {
781 ASSERT(!trans->bytes_reserved);
785 if (!trans->bytes_reserved)
788 ASSERT(trans->block_rsv == &fs_info->trans_block_rsv);
789 trace_btrfs_space_reservation(fs_info, "transaction",
790 trans->transid, trans->bytes_reserved, 0);
791 btrfs_block_rsv_release(fs_info, trans->block_rsv,
792 trans->bytes_reserved);
793 trans->bytes_reserved = 0;
796 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
799 struct btrfs_fs_info *info = trans->fs_info;
800 struct btrfs_transaction *cur_trans = trans->transaction;
801 int lock = (trans->type != TRANS_JOIN_NOLOCK);
804 if (refcount_read(&trans->use_count) > 1) {
805 refcount_dec(&trans->use_count);
806 trans->block_rsv = trans->orig_rsv;
810 btrfs_trans_release_metadata(trans);
811 trans->block_rsv = NULL;
813 btrfs_create_pending_block_groups(trans);
815 btrfs_trans_release_chunk_metadata(trans);
817 if (lock && READ_ONCE(cur_trans->state) == TRANS_STATE_BLOCKED) {
819 return btrfs_commit_transaction(trans);
821 wake_up_process(info->transaction_kthread);
824 if (trans->type & __TRANS_FREEZABLE)
825 sb_end_intwrite(info->sb);
827 WARN_ON(cur_trans != info->running_transaction);
828 WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
829 atomic_dec(&cur_trans->num_writers);
830 extwriter_counter_dec(cur_trans, trans->type);
832 cond_wake_up(&cur_trans->writer_wait);
833 btrfs_put_transaction(cur_trans);
835 if (current->journal_info == trans)
836 current->journal_info = NULL;
839 btrfs_run_delayed_iputs(info);
841 if (trans->aborted ||
842 test_bit(BTRFS_FS_STATE_ERROR, &info->fs_state)) {
843 wake_up_process(info->transaction_kthread);
847 kmem_cache_free(btrfs_trans_handle_cachep, trans);
851 int btrfs_end_transaction(struct btrfs_trans_handle *trans)
853 return __btrfs_end_transaction(trans, 0);
856 int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans)
858 return __btrfs_end_transaction(trans, 1);
862 * when btree blocks are allocated, they have some corresponding bits set for
863 * them in one of two extent_io trees. This is used to make sure all of
864 * those extents are sent to disk but does not wait on them
866 int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info,
867 struct extent_io_tree *dirty_pages, int mark)
871 struct address_space *mapping = fs_info->btree_inode->i_mapping;
872 struct extent_state *cached_state = NULL;
876 atomic_inc(&BTRFS_I(fs_info->btree_inode)->sync_writers);
877 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
878 mark, &cached_state)) {
879 bool wait_writeback = false;
881 err = convert_extent_bit(dirty_pages, start, end,
883 mark, &cached_state);
885 * convert_extent_bit can return -ENOMEM, which is most of the
886 * time a temporary error. So when it happens, ignore the error
887 * and wait for writeback of this range to finish - because we
888 * failed to set the bit EXTENT_NEED_WAIT for the range, a call
889 * to __btrfs_wait_marked_extents() would not know that
890 * writeback for this range started and therefore wouldn't
891 * wait for it to finish - we don't want to commit a
892 * superblock that points to btree nodes/leafs for which
893 * writeback hasn't finished yet (and without errors).
894 * We cleanup any entries left in the io tree when committing
895 * the transaction (through extent_io_tree_release()).
897 if (err == -ENOMEM) {
899 wait_writeback = true;
902 err = filemap_fdatawrite_range(mapping, start, end);
905 else if (wait_writeback)
906 werr = filemap_fdatawait_range(mapping, start, end);
907 free_extent_state(cached_state);
912 atomic_dec(&BTRFS_I(fs_info->btree_inode)->sync_writers);
917 * when btree blocks are allocated, they have some corresponding bits set for
918 * them in one of two extent_io trees. This is used to make sure all of
919 * those extents are on disk for transaction or log commit. We wait
920 * on all the pages and clear them from the dirty pages state tree
922 static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info,
923 struct extent_io_tree *dirty_pages)
927 struct address_space *mapping = fs_info->btree_inode->i_mapping;
928 struct extent_state *cached_state = NULL;
932 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
933 EXTENT_NEED_WAIT, &cached_state)) {
935 * Ignore -ENOMEM errors returned by clear_extent_bit().
936 * When committing the transaction, we'll remove any entries
937 * left in the io tree. For a log commit, we don't remove them
938 * after committing the log because the tree can be accessed
939 * concurrently - we do it only at transaction commit time when
940 * it's safe to do it (through extent_io_tree_release()).
942 err = clear_extent_bit(dirty_pages, start, end,
943 EXTENT_NEED_WAIT, 0, 0, &cached_state);
947 err = filemap_fdatawait_range(mapping, start, end);
950 free_extent_state(cached_state);
960 int btrfs_wait_extents(struct btrfs_fs_info *fs_info,
961 struct extent_io_tree *dirty_pages)
966 err = __btrfs_wait_marked_extents(fs_info, dirty_pages);
967 if (test_and_clear_bit(BTRFS_FS_BTREE_ERR, &fs_info->flags))
975 int btrfs_wait_tree_log_extents(struct btrfs_root *log_root, int mark)
977 struct btrfs_fs_info *fs_info = log_root->fs_info;
978 struct extent_io_tree *dirty_pages = &log_root->dirty_log_pages;
982 ASSERT(log_root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID);
984 err = __btrfs_wait_marked_extents(fs_info, dirty_pages);
985 if ((mark & EXTENT_DIRTY) &&
986 test_and_clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags))
989 if ((mark & EXTENT_NEW) &&
990 test_and_clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags))
999 * When btree blocks are allocated the corresponding extents are marked dirty.
1000 * This function ensures such extents are persisted on disk for transaction or
1003 * @trans: transaction whose dirty pages we'd like to write
1005 static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans)
1009 struct extent_io_tree *dirty_pages = &trans->transaction->dirty_pages;
1010 struct btrfs_fs_info *fs_info = trans->fs_info;
1011 struct blk_plug plug;
1013 blk_start_plug(&plug);
1014 ret = btrfs_write_marked_extents(fs_info, dirty_pages, EXTENT_DIRTY);
1015 blk_finish_plug(&plug);
1016 ret2 = btrfs_wait_extents(fs_info, dirty_pages);
1018 extent_io_tree_release(&trans->transaction->dirty_pages);
1029 * this is used to update the root pointer in the tree of tree roots.
1031 * But, in the case of the extent allocation tree, updating the root
1032 * pointer may allocate blocks which may change the root of the extent
1035 * So, this loops and repeats and makes sure the cowonly root didn't
1036 * change while the root pointer was being updated in the metadata.
1038 static int update_cowonly_root(struct btrfs_trans_handle *trans,
1039 struct btrfs_root *root)
1042 u64 old_root_bytenr;
1044 struct btrfs_fs_info *fs_info = root->fs_info;
1045 struct btrfs_root *tree_root = fs_info->tree_root;
1047 old_root_used = btrfs_root_used(&root->root_item);
1050 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
1051 if (old_root_bytenr == root->node->start &&
1052 old_root_used == btrfs_root_used(&root->root_item))
1055 btrfs_set_root_node(&root->root_item, root->node);
1056 ret = btrfs_update_root(trans, tree_root,
1062 old_root_used = btrfs_root_used(&root->root_item);
1069 * update all the cowonly tree roots on disk
1071 * The error handling in this function may not be obvious. Any of the
1072 * failures will cause the file system to go offline. We still need
1073 * to clean up the delayed refs.
1075 static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans)
1077 struct btrfs_fs_info *fs_info = trans->fs_info;
1078 struct list_head *dirty_bgs = &trans->transaction->dirty_bgs;
1079 struct list_head *io_bgs = &trans->transaction->io_bgs;
1080 struct list_head *next;
1081 struct extent_buffer *eb;
1084 eb = btrfs_lock_root_node(fs_info->tree_root);
1085 ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,
1087 btrfs_tree_unlock(eb);
1088 free_extent_buffer(eb);
1093 ret = btrfs_run_delayed_refs(trans, (unsigned long)-1);
1097 ret = btrfs_run_dev_stats(trans, fs_info);
1100 ret = btrfs_run_dev_replace(trans, fs_info);
1103 ret = btrfs_run_qgroups(trans);
1107 ret = btrfs_setup_space_cache(trans, fs_info);
1111 /* run_qgroups might have added some more refs */
1112 ret = btrfs_run_delayed_refs(trans, (unsigned long)-1);
1116 while (!list_empty(&fs_info->dirty_cowonly_roots)) {
1117 struct btrfs_root *root;
1118 next = fs_info->dirty_cowonly_roots.next;
1119 list_del_init(next);
1120 root = list_entry(next, struct btrfs_root, dirty_list);
1121 clear_bit(BTRFS_ROOT_DIRTY, &root->state);
1123 if (root != fs_info->extent_root)
1124 list_add_tail(&root->dirty_list,
1125 &trans->transaction->switch_commits);
1126 ret = update_cowonly_root(trans, root);
1129 ret = btrfs_run_delayed_refs(trans, (unsigned long)-1);
1134 while (!list_empty(dirty_bgs) || !list_empty(io_bgs)) {
1135 ret = btrfs_write_dirty_block_groups(trans, fs_info);
1138 ret = btrfs_run_delayed_refs(trans, (unsigned long)-1);
1143 if (!list_empty(&fs_info->dirty_cowonly_roots))
1146 list_add_tail(&fs_info->extent_root->dirty_list,
1147 &trans->transaction->switch_commits);
1149 /* Update dev-replace pointer once everything is committed */
1150 fs_info->dev_replace.committed_cursor_left =
1151 fs_info->dev_replace.cursor_left_last_write_of_item;
1157 * dead roots are old snapshots that need to be deleted. This allocates
1158 * a dirty root struct and adds it into the list of dead roots that need to
1161 void btrfs_add_dead_root(struct btrfs_root *root)
1163 struct btrfs_fs_info *fs_info = root->fs_info;
1165 spin_lock(&fs_info->trans_lock);
1166 if (list_empty(&root->root_list))
1167 list_add_tail(&root->root_list, &fs_info->dead_roots);
1168 spin_unlock(&fs_info->trans_lock);
1172 * update all the cowonly tree roots on disk
1174 static noinline int commit_fs_roots(struct btrfs_trans_handle *trans)
1176 struct btrfs_fs_info *fs_info = trans->fs_info;
1177 struct btrfs_root *gang[8];
1182 spin_lock(&fs_info->fs_roots_radix_lock);
1184 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
1187 BTRFS_ROOT_TRANS_TAG);
1190 for (i = 0; i < ret; i++) {
1191 struct btrfs_root *root = gang[i];
1192 radix_tree_tag_clear(&fs_info->fs_roots_radix,
1193 (unsigned long)root->root_key.objectid,
1194 BTRFS_ROOT_TRANS_TAG);
1195 spin_unlock(&fs_info->fs_roots_radix_lock);
1197 btrfs_free_log(trans, root);
1198 btrfs_update_reloc_root(trans, root);
1200 btrfs_save_ino_cache(root, trans);
1202 /* see comments in should_cow_block() */
1203 clear_bit(BTRFS_ROOT_FORCE_COW, &root->state);
1204 smp_mb__after_atomic();
1206 if (root->commit_root != root->node) {
1207 list_add_tail(&root->dirty_list,
1208 &trans->transaction->switch_commits);
1209 btrfs_set_root_node(&root->root_item,
1213 err = btrfs_update_root(trans, fs_info->tree_root,
1216 spin_lock(&fs_info->fs_roots_radix_lock);
1219 btrfs_qgroup_free_meta_all_pertrans(root);
1222 spin_unlock(&fs_info->fs_roots_radix_lock);
1227 * defrag a given btree.
1228 * Every leaf in the btree is read and defragged.
1230 int btrfs_defrag_root(struct btrfs_root *root)
1232 struct btrfs_fs_info *info = root->fs_info;
1233 struct btrfs_trans_handle *trans;
1236 if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state))
1240 trans = btrfs_start_transaction(root, 0);
1242 return PTR_ERR(trans);
1244 ret = btrfs_defrag_leaves(trans, root);
1246 btrfs_end_transaction(trans);
1247 btrfs_btree_balance_dirty(info);
1250 if (btrfs_fs_closing(info) || ret != -EAGAIN)
1253 if (btrfs_defrag_cancelled(info)) {
1254 btrfs_debug(info, "defrag_root cancelled");
1259 clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state);
1264 * Do all special snapshot related qgroup dirty hack.
1266 * Will do all needed qgroup inherit and dirty hack like switch commit
1267 * roots inside one transaction and write all btree into disk, to make
1270 static int qgroup_account_snapshot(struct btrfs_trans_handle *trans,
1271 struct btrfs_root *src,
1272 struct btrfs_root *parent,
1273 struct btrfs_qgroup_inherit *inherit,
1276 struct btrfs_fs_info *fs_info = src->fs_info;
1280 * Save some performance in the case that qgroups are not
1281 * enabled. If this check races with the ioctl, rescan will
1284 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags))
1288 * Ensure dirty @src will be committed. Or, after coming
1289 * commit_fs_roots() and switch_commit_roots(), any dirty but not
1290 * recorded root will never be updated again, causing an outdated root
1293 record_root_in_trans(trans, src, 1);
1296 * We are going to commit transaction, see btrfs_commit_transaction()
1297 * comment for reason locking tree_log_mutex
1299 mutex_lock(&fs_info->tree_log_mutex);
1301 ret = commit_fs_roots(trans);
1304 ret = btrfs_qgroup_account_extents(trans);
1308 /* Now qgroup are all updated, we can inherit it to new qgroups */
1309 ret = btrfs_qgroup_inherit(trans, src->root_key.objectid, dst_objectid,
1315 * Now we do a simplified commit transaction, which will:
1316 * 1) commit all subvolume and extent tree
1317 * To ensure all subvolume and extent tree have a valid
1318 * commit_root to accounting later insert_dir_item()
1319 * 2) write all btree blocks onto disk
1320 * This is to make sure later btree modification will be cowed
1321 * Or commit_root can be populated and cause wrong qgroup numbers
1322 * In this simplified commit, we don't really care about other trees
1323 * like chunk and root tree, as they won't affect qgroup.
1324 * And we don't write super to avoid half committed status.
1326 ret = commit_cowonly_roots(trans);
1329 switch_commit_roots(trans->transaction);
1330 ret = btrfs_write_and_wait_transaction(trans);
1332 btrfs_handle_fs_error(fs_info, ret,
1333 "Error while writing out transaction for qgroup");
1336 mutex_unlock(&fs_info->tree_log_mutex);
1339 * Force parent root to be updated, as we recorded it before so its
1340 * last_trans == cur_transid.
1341 * Or it won't be committed again onto disk after later
1345 record_root_in_trans(trans, parent, 1);
1350 * new snapshots need to be created at a very specific time in the
1351 * transaction commit. This does the actual creation.
1354 * If the error which may affect the commitment of the current transaction
1355 * happens, we should return the error number. If the error which just affect
1356 * the creation of the pending snapshots, just return 0.
1358 static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
1359 struct btrfs_pending_snapshot *pending)
1362 struct btrfs_fs_info *fs_info = trans->fs_info;
1363 struct btrfs_key key;
1364 struct btrfs_root_item *new_root_item;
1365 struct btrfs_root *tree_root = fs_info->tree_root;
1366 struct btrfs_root *root = pending->root;
1367 struct btrfs_root *parent_root;
1368 struct btrfs_block_rsv *rsv;
1369 struct inode *parent_inode;
1370 struct btrfs_path *path;
1371 struct btrfs_dir_item *dir_item;
1372 struct dentry *dentry;
1373 struct extent_buffer *tmp;
1374 struct extent_buffer *old;
1375 struct timespec64 cur_time;
1383 ASSERT(pending->path);
1384 path = pending->path;
1386 ASSERT(pending->root_item);
1387 new_root_item = pending->root_item;
1389 pending->error = btrfs_find_free_objectid(tree_root, &objectid);
1391 goto no_free_objectid;
1394 * Make qgroup to skip current new snapshot's qgroupid, as it is
1395 * accounted by later btrfs_qgroup_inherit().
1397 btrfs_set_skip_qgroup(trans, objectid);
1399 btrfs_reloc_pre_snapshot(pending, &to_reserve);
1401 if (to_reserve > 0) {
1402 pending->error = btrfs_block_rsv_add(root,
1403 &pending->block_rsv,
1405 BTRFS_RESERVE_NO_FLUSH);
1407 goto clear_skip_qgroup;
1410 key.objectid = objectid;
1411 key.offset = (u64)-1;
1412 key.type = BTRFS_ROOT_ITEM_KEY;
1414 rsv = trans->block_rsv;
1415 trans->block_rsv = &pending->block_rsv;
1416 trans->bytes_reserved = trans->block_rsv->reserved;
1417 trace_btrfs_space_reservation(fs_info, "transaction",
1419 trans->bytes_reserved, 1);
1420 dentry = pending->dentry;
1421 parent_inode = pending->dir;
1422 parent_root = BTRFS_I(parent_inode)->root;
1423 record_root_in_trans(trans, parent_root, 0);
1425 cur_time = current_time(parent_inode);
1428 * insert the directory item
1430 ret = btrfs_set_inode_index(BTRFS_I(parent_inode), &index);
1431 BUG_ON(ret); /* -ENOMEM */
1433 /* check if there is a file/dir which has the same name. */
1434 dir_item = btrfs_lookup_dir_item(NULL, parent_root, path,
1435 btrfs_ino(BTRFS_I(parent_inode)),
1436 dentry->d_name.name,
1437 dentry->d_name.len, 0);
1438 if (dir_item != NULL && !IS_ERR(dir_item)) {
1439 pending->error = -EEXIST;
1440 goto dir_item_existed;
1441 } else if (IS_ERR(dir_item)) {
1442 ret = PTR_ERR(dir_item);
1443 btrfs_abort_transaction(trans, ret);
1446 btrfs_release_path(path);
1449 * pull in the delayed directory update
1450 * and the delayed inode item
1451 * otherwise we corrupt the FS during
1454 ret = btrfs_run_delayed_items(trans);
1455 if (ret) { /* Transaction aborted */
1456 btrfs_abort_transaction(trans, ret);
1460 record_root_in_trans(trans, root, 0);
1461 btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
1462 memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
1463 btrfs_check_and_init_root_item(new_root_item);
1465 root_flags = btrfs_root_flags(new_root_item);
1466 if (pending->readonly)
1467 root_flags |= BTRFS_ROOT_SUBVOL_RDONLY;
1469 root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY;
1470 btrfs_set_root_flags(new_root_item, root_flags);
1472 btrfs_set_root_generation_v2(new_root_item,
1474 uuid_le_gen(&new_uuid);
1475 memcpy(new_root_item->uuid, new_uuid.b, BTRFS_UUID_SIZE);
1476 memcpy(new_root_item->parent_uuid, root->root_item.uuid,
1478 if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) {
1479 memset(new_root_item->received_uuid, 0,
1480 sizeof(new_root_item->received_uuid));
1481 memset(&new_root_item->stime, 0, sizeof(new_root_item->stime));
1482 memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime));
1483 btrfs_set_root_stransid(new_root_item, 0);
1484 btrfs_set_root_rtransid(new_root_item, 0);
1486 btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec);
1487 btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec);
1488 btrfs_set_root_otransid(new_root_item, trans->transid);
1490 old = btrfs_lock_root_node(root);
1491 ret = btrfs_cow_block(trans, root, old, NULL, 0, &old);
1493 btrfs_tree_unlock(old);
1494 free_extent_buffer(old);
1495 btrfs_abort_transaction(trans, ret);
1499 btrfs_set_lock_blocking_write(old);
1501 ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
1502 /* clean up in any case */
1503 btrfs_tree_unlock(old);
1504 free_extent_buffer(old);
1506 btrfs_abort_transaction(trans, ret);
1509 /* see comments in should_cow_block() */
1510 set_bit(BTRFS_ROOT_FORCE_COW, &root->state);
1513 btrfs_set_root_node(new_root_item, tmp);
1514 /* record when the snapshot was created in key.offset */
1515 key.offset = trans->transid;
1516 ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
1517 btrfs_tree_unlock(tmp);
1518 free_extent_buffer(tmp);
1520 btrfs_abort_transaction(trans, ret);
1525 * insert root back/forward references
1527 ret = btrfs_add_root_ref(trans, objectid,
1528 parent_root->root_key.objectid,
1529 btrfs_ino(BTRFS_I(parent_inode)), index,
1530 dentry->d_name.name, dentry->d_name.len);
1532 btrfs_abort_transaction(trans, ret);
1536 key.offset = (u64)-1;
1537 pending->snap = btrfs_read_fs_root_no_name(fs_info, &key);
1538 if (IS_ERR(pending->snap)) {
1539 ret = PTR_ERR(pending->snap);
1540 btrfs_abort_transaction(trans, ret);
1544 ret = btrfs_reloc_post_snapshot(trans, pending);
1546 btrfs_abort_transaction(trans, ret);
1550 ret = btrfs_run_delayed_refs(trans, (unsigned long)-1);
1552 btrfs_abort_transaction(trans, ret);
1557 * Do special qgroup accounting for snapshot, as we do some qgroup
1558 * snapshot hack to do fast snapshot.
1559 * To co-operate with that hack, we do hack again.
1560 * Or snapshot will be greatly slowed down by a subtree qgroup rescan
1562 ret = qgroup_account_snapshot(trans, root, parent_root,
1563 pending->inherit, objectid);
1567 ret = btrfs_insert_dir_item(trans, dentry->d_name.name,
1568 dentry->d_name.len, BTRFS_I(parent_inode),
1569 &key, BTRFS_FT_DIR, index);
1570 /* We have check then name at the beginning, so it is impossible. */
1571 BUG_ON(ret == -EEXIST || ret == -EOVERFLOW);
1573 btrfs_abort_transaction(trans, ret);
1577 btrfs_i_size_write(BTRFS_I(parent_inode), parent_inode->i_size +
1578 dentry->d_name.len * 2);
1579 parent_inode->i_mtime = parent_inode->i_ctime =
1580 current_time(parent_inode);
1581 ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode);
1583 btrfs_abort_transaction(trans, ret);
1586 ret = btrfs_uuid_tree_add(trans, new_uuid.b, BTRFS_UUID_KEY_SUBVOL,
1589 btrfs_abort_transaction(trans, ret);
1592 if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) {
1593 ret = btrfs_uuid_tree_add(trans, new_root_item->received_uuid,
1594 BTRFS_UUID_KEY_RECEIVED_SUBVOL,
1596 if (ret && ret != -EEXIST) {
1597 btrfs_abort_transaction(trans, ret);
1602 ret = btrfs_run_delayed_refs(trans, (unsigned long)-1);
1604 btrfs_abort_transaction(trans, ret);
1609 pending->error = ret;
1611 trans->block_rsv = rsv;
1612 trans->bytes_reserved = 0;
1614 btrfs_clear_skip_qgroup(trans);
1616 kfree(new_root_item);
1617 pending->root_item = NULL;
1618 btrfs_free_path(path);
1619 pending->path = NULL;
1625 * create all the snapshots we've scheduled for creation
1627 static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans)
1629 struct btrfs_pending_snapshot *pending, *next;
1630 struct list_head *head = &trans->transaction->pending_snapshots;
1633 list_for_each_entry_safe(pending, next, head, list) {
1634 list_del(&pending->list);
1635 ret = create_pending_snapshot(trans, pending);
1642 static void update_super_roots(struct btrfs_fs_info *fs_info)
1644 struct btrfs_root_item *root_item;
1645 struct btrfs_super_block *super;
1647 super = fs_info->super_copy;
1649 root_item = &fs_info->chunk_root->root_item;
1650 super->chunk_root = root_item->bytenr;
1651 super->chunk_root_generation = root_item->generation;
1652 super->chunk_root_level = root_item->level;
1654 root_item = &fs_info->tree_root->root_item;
1655 super->root = root_item->bytenr;
1656 super->generation = root_item->generation;
1657 super->root_level = root_item->level;
1658 if (btrfs_test_opt(fs_info, SPACE_CACHE))
1659 super->cache_generation = root_item->generation;
1660 if (test_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags))
1661 super->uuid_tree_generation = root_item->generation;
1664 int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
1666 struct btrfs_transaction *trans;
1669 spin_lock(&info->trans_lock);
1670 trans = info->running_transaction;
1672 ret = (trans->state >= TRANS_STATE_COMMIT_START);
1673 spin_unlock(&info->trans_lock);
1677 int btrfs_transaction_blocked(struct btrfs_fs_info *info)
1679 struct btrfs_transaction *trans;
1682 spin_lock(&info->trans_lock);
1683 trans = info->running_transaction;
1685 ret = is_transaction_blocked(trans);
1686 spin_unlock(&info->trans_lock);
1691 * wait for the current transaction commit to start and block subsequent
1694 static void wait_current_trans_commit_start(struct btrfs_fs_info *fs_info,
1695 struct btrfs_transaction *trans)
1697 wait_event(fs_info->transaction_blocked_wait,
1698 trans->state >= TRANS_STATE_COMMIT_START || trans->aborted);
1702 * wait for the current transaction to start and then become unblocked.
1705 static void wait_current_trans_commit_start_and_unblock(
1706 struct btrfs_fs_info *fs_info,
1707 struct btrfs_transaction *trans)
1709 wait_event(fs_info->transaction_wait,
1710 trans->state >= TRANS_STATE_UNBLOCKED || trans->aborted);
1714 * commit transactions asynchronously. once btrfs_commit_transaction_async
1715 * returns, any subsequent transaction will not be allowed to join.
1717 struct btrfs_async_commit {
1718 struct btrfs_trans_handle *newtrans;
1719 struct work_struct work;
1722 static void do_async_commit(struct work_struct *work)
1724 struct btrfs_async_commit *ac =
1725 container_of(work, struct btrfs_async_commit, work);
1728 * We've got freeze protection passed with the transaction.
1729 * Tell lockdep about it.
1731 if (ac->newtrans->type & __TRANS_FREEZABLE)
1732 __sb_writers_acquired(ac->newtrans->fs_info->sb, SB_FREEZE_FS);
1734 current->journal_info = ac->newtrans;
1736 btrfs_commit_transaction(ac->newtrans);
1740 int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
1741 int wait_for_unblock)
1743 struct btrfs_fs_info *fs_info = trans->fs_info;
1744 struct btrfs_async_commit *ac;
1745 struct btrfs_transaction *cur_trans;
1747 ac = kmalloc(sizeof(*ac), GFP_NOFS);
1751 INIT_WORK(&ac->work, do_async_commit);
1752 ac->newtrans = btrfs_join_transaction(trans->root);
1753 if (IS_ERR(ac->newtrans)) {
1754 int err = PTR_ERR(ac->newtrans);
1759 /* take transaction reference */
1760 cur_trans = trans->transaction;
1761 refcount_inc(&cur_trans->use_count);
1763 btrfs_end_transaction(trans);
1766 * Tell lockdep we've released the freeze rwsem, since the
1767 * async commit thread will be the one to unlock it.
1769 if (ac->newtrans->type & __TRANS_FREEZABLE)
1770 __sb_writers_release(fs_info->sb, SB_FREEZE_FS);
1772 schedule_work(&ac->work);
1774 /* wait for transaction to start and unblock */
1775 if (wait_for_unblock)
1776 wait_current_trans_commit_start_and_unblock(fs_info, cur_trans);
1778 wait_current_trans_commit_start(fs_info, cur_trans);
1780 if (current->journal_info == trans)
1781 current->journal_info = NULL;
1783 btrfs_put_transaction(cur_trans);
1788 static void cleanup_transaction(struct btrfs_trans_handle *trans, int err)
1790 struct btrfs_fs_info *fs_info = trans->fs_info;
1791 struct btrfs_transaction *cur_trans = trans->transaction;
1793 WARN_ON(refcount_read(&trans->use_count) > 1);
1795 btrfs_abort_transaction(trans, err);
1797 spin_lock(&fs_info->trans_lock);
1800 * If the transaction is removed from the list, it means this
1801 * transaction has been committed successfully, so it is impossible
1802 * to call the cleanup function.
1804 BUG_ON(list_empty(&cur_trans->list));
1806 list_del_init(&cur_trans->list);
1807 if (cur_trans == fs_info->running_transaction) {
1808 cur_trans->state = TRANS_STATE_COMMIT_DOING;
1809 spin_unlock(&fs_info->trans_lock);
1810 wait_event(cur_trans->writer_wait,
1811 atomic_read(&cur_trans->num_writers) == 1);
1813 spin_lock(&fs_info->trans_lock);
1815 spin_unlock(&fs_info->trans_lock);
1817 btrfs_cleanup_one_transaction(trans->transaction, fs_info);
1819 spin_lock(&fs_info->trans_lock);
1820 if (cur_trans == fs_info->running_transaction)
1821 fs_info->running_transaction = NULL;
1822 spin_unlock(&fs_info->trans_lock);
1824 if (trans->type & __TRANS_FREEZABLE)
1825 sb_end_intwrite(fs_info->sb);
1826 btrfs_put_transaction(cur_trans);
1827 btrfs_put_transaction(cur_trans);
1829 trace_btrfs_transaction_commit(trans->root);
1831 if (current->journal_info == trans)
1832 current->journal_info = NULL;
1833 btrfs_scrub_cancel(fs_info);
1835 kmem_cache_free(btrfs_trans_handle_cachep, trans);
1839 * Release reserved delayed ref space of all pending block groups of the
1840 * transaction and remove them from the list
1842 static void btrfs_cleanup_pending_block_groups(struct btrfs_trans_handle *trans)
1844 struct btrfs_fs_info *fs_info = trans->fs_info;
1845 struct btrfs_block_group_cache *block_group, *tmp;
1847 list_for_each_entry_safe(block_group, tmp, &trans->new_bgs, bg_list) {
1848 btrfs_delayed_refs_rsv_release(fs_info, 1);
1849 list_del_init(&block_group->bg_list);
1853 static inline int btrfs_start_delalloc_flush(struct btrfs_trans_handle *trans)
1855 struct btrfs_fs_info *fs_info = trans->fs_info;
1858 * We use writeback_inodes_sb here because if we used
1859 * btrfs_start_delalloc_roots we would deadlock with fs freeze.
1860 * Currently are holding the fs freeze lock, if we do an async flush
1861 * we'll do btrfs_join_transaction() and deadlock because we need to
1862 * wait for the fs freeze lock. Using the direct flushing we benefit
1863 * from already being in a transaction and our join_transaction doesn't
1864 * have to re-take the fs freeze lock.
1866 if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) {
1867 writeback_inodes_sb(fs_info->sb, WB_REASON_SYNC);
1869 struct btrfs_pending_snapshot *pending;
1870 struct list_head *head = &trans->transaction->pending_snapshots;
1873 * Flush dellaloc for any root that is going to be snapshotted.
1874 * This is done to avoid a corrupted version of files, in the
1875 * snapshots, that had both buffered and direct IO writes (even
1876 * if they were done sequentially) due to an unordered update of
1877 * the inode's size on disk.
1879 list_for_each_entry(pending, head, list) {
1882 ret = btrfs_start_delalloc_snapshot(pending->root);
1890 static inline void btrfs_wait_delalloc_flush(struct btrfs_trans_handle *trans)
1892 struct btrfs_fs_info *fs_info = trans->fs_info;
1894 if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) {
1895 btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
1897 struct btrfs_pending_snapshot *pending;
1898 struct list_head *head = &trans->transaction->pending_snapshots;
1901 * Wait for any dellaloc that we started previously for the roots
1902 * that are going to be snapshotted. This is to avoid a corrupted
1903 * version of files in the snapshots that had both buffered and
1904 * direct IO writes (even if they were done sequentially).
1906 list_for_each_entry(pending, head, list)
1907 btrfs_wait_ordered_extents(pending->root,
1908 U64_MAX, 0, U64_MAX);
1912 int btrfs_commit_transaction(struct btrfs_trans_handle *trans)
1914 struct btrfs_fs_info *fs_info = trans->fs_info;
1915 struct btrfs_transaction *cur_trans = trans->transaction;
1916 struct btrfs_transaction *prev_trans = NULL;
1919 /* Stop the commit early if ->aborted is set */
1920 if (unlikely(READ_ONCE(cur_trans->aborted))) {
1921 ret = cur_trans->aborted;
1922 btrfs_end_transaction(trans);
1926 btrfs_trans_release_metadata(trans);
1927 trans->block_rsv = NULL;
1929 /* make a pass through all the delayed refs we have so far
1930 * any runnings procs may add more while we are here
1932 ret = btrfs_run_delayed_refs(trans, 0);
1934 btrfs_end_transaction(trans);
1938 cur_trans = trans->transaction;
1941 * set the flushing flag so procs in this transaction have to
1942 * start sending their work down.
1944 cur_trans->delayed_refs.flushing = 1;
1947 btrfs_create_pending_block_groups(trans);
1949 ret = btrfs_run_delayed_refs(trans, 0);
1951 btrfs_end_transaction(trans);
1955 if (!test_bit(BTRFS_TRANS_DIRTY_BG_RUN, &cur_trans->flags)) {
1958 /* this mutex is also taken before trying to set
1959 * block groups readonly. We need to make sure
1960 * that nobody has set a block group readonly
1961 * after a extents from that block group have been
1962 * allocated for cache files. btrfs_set_block_group_ro
1963 * will wait for the transaction to commit if it
1964 * finds BTRFS_TRANS_DIRTY_BG_RUN set.
1966 * The BTRFS_TRANS_DIRTY_BG_RUN flag is also used to make sure
1967 * only one process starts all the block group IO. It wouldn't
1968 * hurt to have more than one go through, but there's no
1969 * real advantage to it either.
1971 mutex_lock(&fs_info->ro_block_group_mutex);
1972 if (!test_and_set_bit(BTRFS_TRANS_DIRTY_BG_RUN,
1975 mutex_unlock(&fs_info->ro_block_group_mutex);
1978 ret = btrfs_start_dirty_block_groups(trans);
1980 btrfs_end_transaction(trans);
1986 spin_lock(&fs_info->trans_lock);
1987 if (cur_trans->state >= TRANS_STATE_COMMIT_START) {
1988 spin_unlock(&fs_info->trans_lock);
1989 refcount_inc(&cur_trans->use_count);
1990 ret = btrfs_end_transaction(trans);
1992 wait_for_commit(cur_trans);
1994 if (unlikely(cur_trans->aborted))
1995 ret = cur_trans->aborted;
1997 btrfs_put_transaction(cur_trans);
2002 cur_trans->state = TRANS_STATE_COMMIT_START;
2003 wake_up(&fs_info->transaction_blocked_wait);
2005 if (cur_trans->list.prev != &fs_info->trans_list) {
2006 prev_trans = list_entry(cur_trans->list.prev,
2007 struct btrfs_transaction, list);
2008 if (prev_trans->state != TRANS_STATE_COMPLETED) {
2009 refcount_inc(&prev_trans->use_count);
2010 spin_unlock(&fs_info->trans_lock);
2012 wait_for_commit(prev_trans);
2013 ret = prev_trans->aborted;
2015 btrfs_put_transaction(prev_trans);
2017 goto cleanup_transaction;
2019 spin_unlock(&fs_info->trans_lock);
2022 spin_unlock(&fs_info->trans_lock);
2025 extwriter_counter_dec(cur_trans, trans->type);
2027 ret = btrfs_start_delalloc_flush(trans);
2029 goto cleanup_transaction;
2031 ret = btrfs_run_delayed_items(trans);
2033 goto cleanup_transaction;
2035 wait_event(cur_trans->writer_wait,
2036 extwriter_counter_read(cur_trans) == 0);
2038 /* some pending stuffs might be added after the previous flush. */
2039 ret = btrfs_run_delayed_items(trans);
2041 goto cleanup_transaction;
2043 btrfs_wait_delalloc_flush(trans);
2045 btrfs_scrub_pause(fs_info);
2047 * Ok now we need to make sure to block out any other joins while we
2048 * commit the transaction. We could have started a join before setting
2049 * COMMIT_DOING so make sure to wait for num_writers to == 1 again.
2051 spin_lock(&fs_info->trans_lock);
2052 cur_trans->state = TRANS_STATE_COMMIT_DOING;
2053 spin_unlock(&fs_info->trans_lock);
2054 wait_event(cur_trans->writer_wait,
2055 atomic_read(&cur_trans->num_writers) == 1);
2057 /* ->aborted might be set after the previous check, so check it */
2058 if (unlikely(READ_ONCE(cur_trans->aborted))) {
2059 ret = cur_trans->aborted;
2060 goto scrub_continue;
2063 * the reloc mutex makes sure that we stop
2064 * the balancing code from coming in and moving
2065 * extents around in the middle of the commit
2067 mutex_lock(&fs_info->reloc_mutex);
2070 * We needn't worry about the delayed items because we will
2071 * deal with them in create_pending_snapshot(), which is the
2072 * core function of the snapshot creation.
2074 ret = create_pending_snapshots(trans);
2076 mutex_unlock(&fs_info->reloc_mutex);
2077 goto scrub_continue;
2081 * We insert the dir indexes of the snapshots and update the inode
2082 * of the snapshots' parents after the snapshot creation, so there
2083 * are some delayed items which are not dealt with. Now deal with
2086 * We needn't worry that this operation will corrupt the snapshots,
2087 * because all the tree which are snapshoted will be forced to COW
2088 * the nodes and leaves.
2090 ret = btrfs_run_delayed_items(trans);
2092 mutex_unlock(&fs_info->reloc_mutex);
2093 goto scrub_continue;
2096 ret = btrfs_run_delayed_refs(trans, (unsigned long)-1);
2098 mutex_unlock(&fs_info->reloc_mutex);
2099 goto scrub_continue;
2103 * make sure none of the code above managed to slip in a
2106 btrfs_assert_delayed_root_empty(fs_info);
2108 WARN_ON(cur_trans != trans->transaction);
2110 /* btrfs_commit_tree_roots is responsible for getting the
2111 * various roots consistent with each other. Every pointer
2112 * in the tree of tree roots has to point to the most up to date
2113 * root for every subvolume and other tree. So, we have to keep
2114 * the tree logging code from jumping in and changing any
2117 * At this point in the commit, there can't be any tree-log
2118 * writers, but a little lower down we drop the trans mutex
2119 * and let new people in. By holding the tree_log_mutex
2120 * from now until after the super is written, we avoid races
2121 * with the tree-log code.
2123 mutex_lock(&fs_info->tree_log_mutex);
2125 ret = commit_fs_roots(trans);
2127 mutex_unlock(&fs_info->tree_log_mutex);
2128 mutex_unlock(&fs_info->reloc_mutex);
2129 goto scrub_continue;
2133 * Since the transaction is done, we can apply the pending changes
2134 * before the next transaction.
2136 btrfs_apply_pending_changes(fs_info);
2138 /* commit_fs_roots gets rid of all the tree log roots, it is now
2139 * safe to free the root of tree log roots
2141 btrfs_free_log_root_tree(trans, fs_info);
2144 * commit_fs_roots() can call btrfs_save_ino_cache(), which generates
2145 * new delayed refs. Must handle them or qgroup can be wrong.
2147 ret = btrfs_run_delayed_refs(trans, (unsigned long)-1);
2149 mutex_unlock(&fs_info->tree_log_mutex);
2150 mutex_unlock(&fs_info->reloc_mutex);
2151 goto scrub_continue;
2155 * Since fs roots are all committed, we can get a quite accurate
2156 * new_roots. So let's do quota accounting.
2158 ret = btrfs_qgroup_account_extents(trans);
2160 mutex_unlock(&fs_info->tree_log_mutex);
2161 mutex_unlock(&fs_info->reloc_mutex);
2162 goto scrub_continue;
2165 ret = commit_cowonly_roots(trans);
2167 mutex_unlock(&fs_info->tree_log_mutex);
2168 mutex_unlock(&fs_info->reloc_mutex);
2169 goto scrub_continue;
2173 * The tasks which save the space cache and inode cache may also
2174 * update ->aborted, check it.
2176 if (unlikely(READ_ONCE(cur_trans->aborted))) {
2177 ret = cur_trans->aborted;
2178 mutex_unlock(&fs_info->tree_log_mutex);
2179 mutex_unlock(&fs_info->reloc_mutex);
2180 goto scrub_continue;
2183 btrfs_prepare_extent_commit(fs_info);
2185 cur_trans = fs_info->running_transaction;
2187 btrfs_set_root_node(&fs_info->tree_root->root_item,
2188 fs_info->tree_root->node);
2189 list_add_tail(&fs_info->tree_root->dirty_list,
2190 &cur_trans->switch_commits);
2192 btrfs_set_root_node(&fs_info->chunk_root->root_item,
2193 fs_info->chunk_root->node);
2194 list_add_tail(&fs_info->chunk_root->dirty_list,
2195 &cur_trans->switch_commits);
2197 switch_commit_roots(cur_trans);
2199 ASSERT(list_empty(&cur_trans->dirty_bgs));
2200 ASSERT(list_empty(&cur_trans->io_bgs));
2201 update_super_roots(fs_info);
2203 btrfs_set_super_log_root(fs_info->super_copy, 0);
2204 btrfs_set_super_log_root_level(fs_info->super_copy, 0);
2205 memcpy(fs_info->super_for_commit, fs_info->super_copy,
2206 sizeof(*fs_info->super_copy));
2208 btrfs_commit_device_sizes(cur_trans);
2210 clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags);
2211 clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags);
2213 btrfs_trans_release_chunk_metadata(trans);
2215 spin_lock(&fs_info->trans_lock);
2216 cur_trans->state = TRANS_STATE_UNBLOCKED;
2217 fs_info->running_transaction = NULL;
2218 spin_unlock(&fs_info->trans_lock);
2219 mutex_unlock(&fs_info->reloc_mutex);
2221 wake_up(&fs_info->transaction_wait);
2223 ret = btrfs_write_and_wait_transaction(trans);
2225 btrfs_handle_fs_error(fs_info, ret,
2226 "Error while writing out transaction");
2227 mutex_unlock(&fs_info->tree_log_mutex);
2228 goto scrub_continue;
2231 ret = write_all_supers(fs_info, 0);
2233 * the super is written, we can safely allow the tree-loggers
2234 * to go about their business
2236 mutex_unlock(&fs_info->tree_log_mutex);
2238 goto scrub_continue;
2240 btrfs_finish_extent_commit(trans);
2242 if (test_bit(BTRFS_TRANS_HAVE_FREE_BGS, &cur_trans->flags))
2243 btrfs_clear_space_info_full(fs_info);
2245 fs_info->last_trans_committed = cur_trans->transid;
2247 * We needn't acquire the lock here because there is no other task
2248 * which can change it.
2250 cur_trans->state = TRANS_STATE_COMPLETED;
2251 wake_up(&cur_trans->commit_wait);
2252 clear_bit(BTRFS_FS_NEED_ASYNC_COMMIT, &fs_info->flags);
2254 spin_lock(&fs_info->trans_lock);
2255 list_del_init(&cur_trans->list);
2256 spin_unlock(&fs_info->trans_lock);
2258 btrfs_put_transaction(cur_trans);
2259 btrfs_put_transaction(cur_trans);
2261 if (trans->type & __TRANS_FREEZABLE)
2262 sb_end_intwrite(fs_info->sb);
2264 trace_btrfs_transaction_commit(trans->root);
2266 btrfs_scrub_continue(fs_info);
2268 if (current->journal_info == trans)
2269 current->journal_info = NULL;
2271 kmem_cache_free(btrfs_trans_handle_cachep, trans);
2276 btrfs_scrub_continue(fs_info);
2277 cleanup_transaction:
2278 btrfs_trans_release_metadata(trans);
2279 btrfs_cleanup_pending_block_groups(trans);
2280 btrfs_trans_release_chunk_metadata(trans);
2281 trans->block_rsv = NULL;
2282 btrfs_warn(fs_info, "Skipping commit of aborted transaction.");
2283 if (current->journal_info == trans)
2284 current->journal_info = NULL;
2285 cleanup_transaction(trans, ret);
2291 * return < 0 if error
2292 * 0 if there are no more dead_roots at the time of call
2293 * 1 there are more to be processed, call me again
2295 * The return value indicates there are certainly more snapshots to delete, but
2296 * if there comes a new one during processing, it may return 0. We don't mind,
2297 * because btrfs_commit_super will poke cleaner thread and it will process it a
2298 * few seconds later.
2300 int btrfs_clean_one_deleted_snapshot(struct btrfs_root *root)
2303 struct btrfs_fs_info *fs_info = root->fs_info;
2305 spin_lock(&fs_info->trans_lock);
2306 if (list_empty(&fs_info->dead_roots)) {
2307 spin_unlock(&fs_info->trans_lock);
2310 root = list_first_entry(&fs_info->dead_roots,
2311 struct btrfs_root, root_list);
2312 list_del_init(&root->root_list);
2313 spin_unlock(&fs_info->trans_lock);
2315 btrfs_debug(fs_info, "cleaner removing %llu", root->root_key.objectid);
2317 btrfs_kill_all_delayed_nodes(root);
2319 if (btrfs_header_backref_rev(root->node) <
2320 BTRFS_MIXED_BACKREF_REV)
2321 ret = btrfs_drop_snapshot(root, NULL, 0, 0);
2323 ret = btrfs_drop_snapshot(root, NULL, 1, 0);
2325 return (ret < 0) ? 0 : 1;
2328 void btrfs_apply_pending_changes(struct btrfs_fs_info *fs_info)
2333 prev = xchg(&fs_info->pending_changes, 0);
2337 bit = 1 << BTRFS_PENDING_SET_INODE_MAP_CACHE;
2339 btrfs_set_opt(fs_info->mount_opt, INODE_MAP_CACHE);
2342 bit = 1 << BTRFS_PENDING_CLEAR_INODE_MAP_CACHE;
2344 btrfs_clear_opt(fs_info->mount_opt, INODE_MAP_CACHE);
2347 bit = 1 << BTRFS_PENDING_COMMIT;
2349 btrfs_debug(fs_info, "pending commit done");
2354 "unknown pending changes left 0x%lx, ignoring", prev);