blob: a5b06442f0bf9d1630f201da3e0eb5c0422e8cc9 [file] [log] [blame]
Chris Mason6cbd5572007-06-12 09:07:21 -04001/*
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
Chris Mason79154b12007-03-22 15:59:16 -040019#include <linux/fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090020#include <linux/slab.h>
Chris Mason34088782007-06-12 11:36:58 -040021#include <linux/sched.h>
Chris Masond3c2fdcf2007-09-17 10:58:06 -040022#include <linux/writeback.h>
Chris Mason5f39d392007-10-15 16:14:19 -040023#include <linux/pagemap.h>
Chris Mason5f2cc082008-11-07 18:22:45 -050024#include <linux/blkdev.h>
Alexander Block8ea05e32012-07-25 17:35:53 +020025#include <linux/uuid.h>
Chris Mason79154b12007-03-22 15:59:16 -040026#include "ctree.h"
27#include "disk-io.h"
28#include "transaction.h"
Chris Mason925baed2008-06-25 16:01:30 -040029#include "locking.h"
Chris Masone02119d2008-09-05 16:13:11 -040030#include "tree-log.h"
Li Zefan581bb052011-04-20 10:06:11 +080031#include "inode-map.h"
Stefan Behrens733f4fb2012-05-25 16:06:10 +020032#include "volumes.h"
Stefan Behrens8dabb742012-11-06 13:15:27 +010033#include "dev-replace.h"
Josef Bacikfcebe452014-05-13 17:30:47 -070034#include "qgroup.h"
Chris Mason79154b12007-03-22 15:59:16 -040035
Chris Mason0f7d52f2007-04-09 10:42:37 -040036#define BTRFS_ROOT_TRANS_TAG 0
37
David Sterbae8c9f182015-01-02 18:23:10 +010038static const unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = {
Miao Xie4a9d8bd2013-05-17 03:53:43 +000039 [TRANS_STATE_RUNNING] = 0U,
40 [TRANS_STATE_BLOCKED] = (__TRANS_USERSPACE |
41 __TRANS_START),
42 [TRANS_STATE_COMMIT_START] = (__TRANS_USERSPACE |
43 __TRANS_START |
44 __TRANS_ATTACH),
45 [TRANS_STATE_COMMIT_DOING] = (__TRANS_USERSPACE |
46 __TRANS_START |
47 __TRANS_ATTACH |
48 __TRANS_JOIN),
49 [TRANS_STATE_UNBLOCKED] = (__TRANS_USERSPACE |
50 __TRANS_START |
51 __TRANS_ATTACH |
52 __TRANS_JOIN |
53 __TRANS_JOIN_NOLOCK),
54 [TRANS_STATE_COMPLETED] = (__TRANS_USERSPACE |
55 __TRANS_START |
56 __TRANS_ATTACH |
57 __TRANS_JOIN |
58 __TRANS_JOIN_NOLOCK),
59};
60
Josef Bacik724e2312013-09-30 11:36:38 -040061void btrfs_put_transaction(struct btrfs_transaction *transaction)
Chris Mason79154b12007-03-22 15:59:16 -040062{
Josef Bacik13c5a932011-04-11 15:45:29 -040063 WARN_ON(atomic_read(&transaction->use_count) == 0);
64 if (atomic_dec_and_test(&transaction->use_count)) {
Josef Bacika4abeea2011-04-11 17:25:13 -040065 BUG_ON(!list_empty(&transaction->list));
Liu Boc46effa2013-10-14 12:59:45 +080066 WARN_ON(!RB_EMPTY_ROOT(&transaction->delayed_refs.href_root));
Josef Bacik12621332015-02-03 07:50:16 -080067 if (transaction->delayed_refs.pending_csums)
68 printk(KERN_ERR "pending csums is %llu\n",
69 transaction->delayed_refs.pending_csums);
Josef Bacik6df9a952013-06-27 13:22:46 -040070 while (!list_empty(&transaction->pending_chunks)) {
71 struct extent_map *em;
72
73 em = list_first_entry(&transaction->pending_chunks,
74 struct extent_map, list);
75 list_del_init(&em->list);
76 free_extent_map(em);
77 }
Chris Mason2c90e5d2007-04-02 10:50:19 -040078 kmem_cache_free(btrfs_transaction_cachep, transaction);
Chris Mason78fae272007-03-25 11:35:08 -040079 }
Chris Mason79154b12007-03-22 15:59:16 -040080}
81
Filipe Manana663dfbb2014-10-13 12:28:37 +010082static void clear_btree_io_tree(struct extent_io_tree *tree)
83{
84 spin_lock(&tree->lock);
85 while (!RB_EMPTY_ROOT(&tree->state)) {
86 struct rb_node *node;
87 struct extent_state *state;
88
89 node = rb_first(&tree->state);
90 state = rb_entry(node, struct extent_state, rb_node);
91 rb_erase(&state->rb_node, &tree->state);
92 RB_CLEAR_NODE(&state->rb_node);
93 /*
94 * btree io trees aren't supposed to have tasks waiting for
95 * changes in the flags of extent states ever.
96 */
97 ASSERT(!waitqueue_active(&state->wq));
98 free_extent_state(state);
David Sterba351810c2015-01-08 15:20:54 +010099
100 cond_resched_lock(&tree->lock);
Filipe Manana663dfbb2014-10-13 12:28:37 +0100101 }
102 spin_unlock(&tree->lock);
103}
104
Josef Bacik9e351cc2014-03-13 15:42:13 -0400105static noinline void switch_commit_roots(struct btrfs_transaction *trans,
106 struct btrfs_fs_info *fs_info)
Josef Bacik817d52f2009-07-13 21:29:25 -0400107{
Josef Bacik9e351cc2014-03-13 15:42:13 -0400108 struct btrfs_root *root, *tmp;
109
110 down_write(&fs_info->commit_root_sem);
111 list_for_each_entry_safe(root, tmp, &trans->switch_commits,
112 dirty_list) {
113 list_del_init(&root->dirty_list);
114 free_extent_buffer(root->commit_root);
115 root->commit_root = btrfs_root_node(root);
116 if (is_fstree(root->objectid))
117 btrfs_unpin_free_ino(root);
Filipe Manana663dfbb2014-10-13 12:28:37 +0100118 clear_btree_io_tree(&root->dirty_log_pages);
Josef Bacik9e351cc2014-03-13 15:42:13 -0400119 }
Josef Bacik2b9dbef2015-09-15 10:07:04 -0400120
121 /* We can free old roots now. */
122 spin_lock(&trans->dropped_roots_lock);
123 while (!list_empty(&trans->dropped_roots)) {
124 root = list_first_entry(&trans->dropped_roots,
125 struct btrfs_root, root_list);
126 list_del_init(&root->root_list);
127 spin_unlock(&trans->dropped_roots_lock);
128 btrfs_drop_and_free_fs_root(fs_info, root);
129 spin_lock(&trans->dropped_roots_lock);
130 }
131 spin_unlock(&trans->dropped_roots_lock);
Josef Bacik9e351cc2014-03-13 15:42:13 -0400132 up_write(&fs_info->commit_root_sem);
Josef Bacik817d52f2009-07-13 21:29:25 -0400133}
134
Miao Xie0860adf2013-05-15 07:48:27 +0000135static inline void extwriter_counter_inc(struct btrfs_transaction *trans,
136 unsigned int type)
137{
138 if (type & TRANS_EXTWRITERS)
139 atomic_inc(&trans->num_extwriters);
140}
141
142static inline void extwriter_counter_dec(struct btrfs_transaction *trans,
143 unsigned int type)
144{
145 if (type & TRANS_EXTWRITERS)
146 atomic_dec(&trans->num_extwriters);
147}
148
149static inline void extwriter_counter_init(struct btrfs_transaction *trans,
150 unsigned int type)
151{
152 atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0));
153}
154
155static inline int extwriter_counter_read(struct btrfs_transaction *trans)
156{
157 return atomic_read(&trans->num_extwriters);
Miao Xie178260b2013-02-20 09:16:24 +0000158}
159
Chris Masond352ac62008-09-29 15:18:18 -0400160/*
161 * either allocate a new transaction or hop into the existing one
162 */
Miao Xie0860adf2013-05-15 07:48:27 +0000163static noinline int join_transaction(struct btrfs_root *root, unsigned int type)
Chris Mason79154b12007-03-22 15:59:16 -0400164{
165 struct btrfs_transaction *cur_trans;
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200166 struct btrfs_fs_info *fs_info = root->fs_info;
Josef Bacika4abeea2011-04-11 17:25:13 -0400167
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200168 spin_lock(&fs_info->trans_lock);
Chris Masond43317d2011-11-06 03:26:19 -0500169loop:
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100170 /* The file system has been taken offline. No new transactions. */
Miao Xie87533c42013-01-29 10:14:48 +0000171 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200172 spin_unlock(&fs_info->trans_lock);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100173 return -EROFS;
174 }
175
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200176 cur_trans = fs_info->running_transaction;
Josef Bacika4abeea2011-04-11 17:25:13 -0400177 if (cur_trans) {
David Sterba871383b2012-04-02 18:31:37 +0200178 if (cur_trans->aborted) {
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200179 spin_unlock(&fs_info->trans_lock);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100180 return cur_trans->aborted;
David Sterba871383b2012-04-02 18:31:37 +0200181 }
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000182 if (btrfs_blocked_trans_types[cur_trans->state] & type) {
Miao Xie178260b2013-02-20 09:16:24 +0000183 spin_unlock(&fs_info->trans_lock);
184 return -EBUSY;
185 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400186 atomic_inc(&cur_trans->use_count);
Josef Bacik13c5a932011-04-11 15:45:29 -0400187 atomic_inc(&cur_trans->num_writers);
Miao Xie0860adf2013-05-15 07:48:27 +0000188 extwriter_counter_inc(cur_trans, type);
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200189 spin_unlock(&fs_info->trans_lock);
Josef Bacika4abeea2011-04-11 17:25:13 -0400190 return 0;
Chris Mason79154b12007-03-22 15:59:16 -0400191 }
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200192 spin_unlock(&fs_info->trans_lock);
Josef Bacika4abeea2011-04-11 17:25:13 -0400193
Miao Xie354aa0f2012-09-20 01:54:00 -0600194 /*
195 * If we are ATTACH, we just want to catch the current transaction,
196 * and commit it. If there is no transaction, just return ENOENT.
197 */
198 if (type == TRANS_ATTACH)
199 return -ENOENT;
200
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000201 /*
202 * JOIN_NOLOCK only happens during the transaction commit, so
203 * it is impossible that ->running_transaction is NULL
204 */
205 BUG_ON(type == TRANS_JOIN_NOLOCK);
206
Josef Bacika4abeea2011-04-11 17:25:13 -0400207 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
208 if (!cur_trans)
209 return -ENOMEM;
Chris Masond43317d2011-11-06 03:26:19 -0500210
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200211 spin_lock(&fs_info->trans_lock);
212 if (fs_info->running_transaction) {
Chris Masond43317d2011-11-06 03:26:19 -0500213 /*
214 * someone started a transaction after we unlocked. Make sure
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000215 * to redo the checks above
Chris Masond43317d2011-11-06 03:26:19 -0500216 */
Josef Bacika4abeea2011-04-11 17:25:13 -0400217 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
Chris Masond43317d2011-11-06 03:26:19 -0500218 goto loop;
Miao Xie87533c42013-01-29 10:14:48 +0000219 } else if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
Dan Carpentere4b50e12012-06-19 13:30:11 +0300220 spin_unlock(&fs_info->trans_lock);
Josef Bacik7b8b92a2012-05-31 15:52:43 -0400221 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
222 return -EROFS;
Josef Bacika4abeea2011-04-11 17:25:13 -0400223 }
Chris Masond43317d2011-11-06 03:26:19 -0500224
Josef Bacika4abeea2011-04-11 17:25:13 -0400225 atomic_set(&cur_trans->num_writers, 1);
Miao Xie0860adf2013-05-15 07:48:27 +0000226 extwriter_counter_init(cur_trans, type);
Josef Bacika4abeea2011-04-11 17:25:13 -0400227 init_waitqueue_head(&cur_trans->writer_wait);
228 init_waitqueue_head(&cur_trans->commit_wait);
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000229 cur_trans->state = TRANS_STATE_RUNNING;
Josef Bacika4abeea2011-04-11 17:25:13 -0400230 /*
231 * One for this trans handle, one so it will live on until we
232 * commit the transaction.
233 */
234 atomic_set(&cur_trans->use_count, 2);
Zhao Lei13212b52015-02-12 14:18:17 +0800235 cur_trans->have_free_bgs = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -0400236 cur_trans->start_time = get_seconds();
Chris Mason1bbc6212015-04-06 12:46:08 -0700237 cur_trans->dirty_bg_run = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -0400238
Liu Boc46effa2013-10-14 12:59:45 +0800239 cur_trans->delayed_refs.href_root = RB_ROOT;
Qu Wenruo3368d002015-04-16 14:34:17 +0800240 cur_trans->delayed_refs.dirty_extent_root = RB_ROOT;
Josef Bacikd7df2c72014-01-23 09:21:38 -0500241 atomic_set(&cur_trans->delayed_refs.num_entries, 0);
Josef Bacika4abeea2011-04-11 17:25:13 -0400242 cur_trans->delayed_refs.num_heads_ready = 0;
Josef Bacik12621332015-02-03 07:50:16 -0800243 cur_trans->delayed_refs.pending_csums = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -0400244 cur_trans->delayed_refs.num_heads = 0;
245 cur_trans->delayed_refs.flushing = 0;
246 cur_trans->delayed_refs.run_delayed_start = 0;
Qu Wenruo9086db82015-04-20 09:53:50 +0800247 cur_trans->delayed_refs.qgroup_to_skip = 0;
Jan Schmidt20b297d2012-05-20 15:43:53 +0200248
249 /*
250 * although the tree mod log is per file system and not per transaction,
251 * the log must never go across transaction boundaries.
252 */
253 smp_mb();
Julia Lawall31b1a2b2012-11-03 10:58:34 +0000254 if (!list_empty(&fs_info->tree_mod_seq_list))
Frank Holtonefe120a2013-12-20 11:37:06 -0500255 WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when "
Jan Schmidt20b297d2012-05-20 15:43:53 +0200256 "creating a fresh transaction\n");
Julia Lawall31b1a2b2012-11-03 10:58:34 +0000257 if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log))
Frank Holtonefe120a2013-12-20 11:37:06 -0500258 WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when "
Jan Schmidt20b297d2012-05-20 15:43:53 +0200259 "creating a fresh transaction\n");
Jan Schmidtfc36ed7e2013-04-24 16:57:33 +0000260 atomic64_set(&fs_info->tree_mod_seq, 0);
Jan Schmidt20b297d2012-05-20 15:43:53 +0200261
Josef Bacika4abeea2011-04-11 17:25:13 -0400262 spin_lock_init(&cur_trans->delayed_refs.lock);
263
264 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
Josef Bacik6df9a952013-06-27 13:22:46 -0400265 INIT_LIST_HEAD(&cur_trans->pending_chunks);
Josef Bacik9e351cc2014-03-13 15:42:13 -0400266 INIT_LIST_HEAD(&cur_trans->switch_commits);
Josef Bacik50d9aa92014-11-21 14:52:38 -0500267 INIT_LIST_HEAD(&cur_trans->pending_ordered);
Josef Bacikce93ec52014-11-17 15:45:48 -0500268 INIT_LIST_HEAD(&cur_trans->dirty_bgs);
Chris Mason1bbc6212015-04-06 12:46:08 -0700269 INIT_LIST_HEAD(&cur_trans->io_bgs);
Josef Bacik2b9dbef2015-09-15 10:07:04 -0400270 INIT_LIST_HEAD(&cur_trans->dropped_roots);
Chris Mason1bbc6212015-04-06 12:46:08 -0700271 mutex_init(&cur_trans->cache_write_mutex);
Josef Bacikcb723e42015-02-18 08:06:57 -0800272 cur_trans->num_dirty_bgs = 0;
Josef Bacikce93ec52014-11-17 15:45:48 -0500273 spin_lock_init(&cur_trans->dirty_bgs_lock);
Jeff Mahoneye33e17e2015-06-15 09:41:19 -0400274 INIT_LIST_HEAD(&cur_trans->deleted_bgs);
275 spin_lock_init(&cur_trans->deleted_bgs_lock);
Josef Bacik2b9dbef2015-09-15 10:07:04 -0400276 spin_lock_init(&cur_trans->dropped_roots_lock);
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200277 list_add_tail(&cur_trans->list, &fs_info->trans_list);
Josef Bacika4abeea2011-04-11 17:25:13 -0400278 extent_io_tree_init(&cur_trans->dirty_pages,
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200279 fs_info->btree_inode->i_mapping);
280 fs_info->generation++;
281 cur_trans->transid = fs_info->generation;
282 fs_info->running_transaction = cur_trans;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100283 cur_trans->aborted = 0;
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200284 spin_unlock(&fs_info->trans_lock);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400285
Chris Mason79154b12007-03-22 15:59:16 -0400286 return 0;
287}
288
Chris Masond352ac62008-09-29 15:18:18 -0400289/*
Chris Masond3977122009-01-05 21:25:51 -0500290 * this does all the record keeping required to make sure that a reference
291 * counted root is properly recorded in a given transaction. This is required
292 * to make sure the old root from before we joined the transaction is deleted
293 * when the transaction commits
Chris Masond352ac62008-09-29 15:18:18 -0400294 */
Chris Mason75857172011-06-13 20:00:16 -0400295static int record_root_in_trans(struct btrfs_trans_handle *trans,
Josef Bacika4abeea2011-04-11 17:25:13 -0400296 struct btrfs_root *root)
Chris Mason6702ed42007-08-07 16:15:09 -0400297{
Miao Xie27cdeb72014-04-02 19:51:05 +0800298 if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) &&
299 root->last_trans < trans->transid) {
Chris Mason6702ed42007-08-07 16:15:09 -0400300 WARN_ON(root == root->fs_info->extent_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400301 WARN_ON(root->commit_root != root->node);
Yan Zheng31153d82008-07-28 15:32:19 -0400302
Chris Mason75857172011-06-13 20:00:16 -0400303 /*
Miao Xie27cdeb72014-04-02 19:51:05 +0800304 * see below for IN_TRANS_SETUP usage rules
Chris Mason75857172011-06-13 20:00:16 -0400305 * we have the reloc mutex held now, so there
306 * is only one writer in this function
307 */
Miao Xie27cdeb72014-04-02 19:51:05 +0800308 set_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state);
Chris Mason75857172011-06-13 20:00:16 -0400309
Miao Xie27cdeb72014-04-02 19:51:05 +0800310 /* make sure readers find IN_TRANS_SETUP before
Chris Mason75857172011-06-13 20:00:16 -0400311 * they find our root->last_trans update
312 */
313 smp_wmb();
314
Josef Bacika4abeea2011-04-11 17:25:13 -0400315 spin_lock(&root->fs_info->fs_roots_radix_lock);
316 if (root->last_trans == trans->transid) {
317 spin_unlock(&root->fs_info->fs_roots_radix_lock);
318 return 0;
319 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400320 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
321 (unsigned long)root->root_key.objectid,
322 BTRFS_ROOT_TRANS_TAG);
Josef Bacika4abeea2011-04-11 17:25:13 -0400323 spin_unlock(&root->fs_info->fs_roots_radix_lock);
Chris Mason75857172011-06-13 20:00:16 -0400324 root->last_trans = trans->transid;
325
326 /* this is pretty tricky. We don't want to
327 * take the relocation lock in btrfs_record_root_in_trans
328 * unless we're really doing the first setup for this root in
329 * this transaction.
330 *
331 * Normally we'd use root->last_trans as a flag to decide
332 * if we want to take the expensive mutex.
333 *
334 * But, we have to set root->last_trans before we
335 * init the relocation root, otherwise, we trip over warnings
336 * in ctree.c. The solution used here is to flag ourselves
Miao Xie27cdeb72014-04-02 19:51:05 +0800337 * with root IN_TRANS_SETUP. When this is 1, we're still
Chris Mason75857172011-06-13 20:00:16 -0400338 * fixing up the reloc trees and everyone must wait.
339 *
340 * When this is zero, they can trust root->last_trans and fly
341 * through btrfs_record_root_in_trans without having to take the
342 * lock. smp_wmb() makes sure that all the writes above are
343 * done before we pop in the zero below
344 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400345 btrfs_init_reloc_root(trans, root);
Chris Masonc7548af2014-06-10 13:06:56 -0700346 smp_mb__before_atomic();
Miao Xie27cdeb72014-04-02 19:51:05 +0800347 clear_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state);
Chris Mason6702ed42007-08-07 16:15:09 -0400348 }
349 return 0;
350}
351
Chris Mason75857172011-06-13 20:00:16 -0400352
Josef Bacik2b9dbef2015-09-15 10:07:04 -0400353void btrfs_add_dropped_root(struct btrfs_trans_handle *trans,
354 struct btrfs_root *root)
355{
356 struct btrfs_transaction *cur_trans = trans->transaction;
357
358 /* Add ourselves to the transaction dropped list */
359 spin_lock(&cur_trans->dropped_roots_lock);
360 list_add_tail(&root->root_list, &cur_trans->dropped_roots);
361 spin_unlock(&cur_trans->dropped_roots_lock);
362
363 /* Make sure we don't try to update the root at commit time */
364 spin_lock(&root->fs_info->fs_roots_radix_lock);
365 radix_tree_tag_clear(&root->fs_info->fs_roots_radix,
366 (unsigned long)root->root_key.objectid,
367 BTRFS_ROOT_TRANS_TAG);
368 spin_unlock(&root->fs_info->fs_roots_radix_lock);
369}
370
Chris Mason75857172011-06-13 20:00:16 -0400371int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
372 struct btrfs_root *root)
373{
Miao Xie27cdeb72014-04-02 19:51:05 +0800374 if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))
Chris Mason75857172011-06-13 20:00:16 -0400375 return 0;
376
377 /*
Miao Xie27cdeb72014-04-02 19:51:05 +0800378 * see record_root_in_trans for comments about IN_TRANS_SETUP usage
Chris Mason75857172011-06-13 20:00:16 -0400379 * and barriers
380 */
381 smp_rmb();
382 if (root->last_trans == trans->transid &&
Miao Xie27cdeb72014-04-02 19:51:05 +0800383 !test_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state))
Chris Mason75857172011-06-13 20:00:16 -0400384 return 0;
385
386 mutex_lock(&root->fs_info->reloc_mutex);
387 record_root_in_trans(trans, root);
388 mutex_unlock(&root->fs_info->reloc_mutex);
389
390 return 0;
391}
392
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000393static inline int is_transaction_blocked(struct btrfs_transaction *trans)
394{
395 return (trans->state >= TRANS_STATE_BLOCKED &&
Josef Bacik501407a2013-06-10 16:47:23 -0400396 trans->state < TRANS_STATE_UNBLOCKED &&
397 !trans->aborted);
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000398}
399
Chris Masond352ac62008-09-29 15:18:18 -0400400/* wait for commit against the current transaction to become unblocked
401 * when this is done, it is safe to start a new transaction, but the current
402 * transaction might not be fully on disk.
403 */
Chris Mason37d1aee2008-07-31 10:48:37 -0400404static void wait_current_trans(struct btrfs_root *root)
Chris Mason79154b12007-03-22 15:59:16 -0400405{
Chris Masonf9295742008-07-17 12:54:14 -0400406 struct btrfs_transaction *cur_trans;
Chris Mason79154b12007-03-22 15:59:16 -0400407
Josef Bacika4abeea2011-04-11 17:25:13 -0400408 spin_lock(&root->fs_info->trans_lock);
Chris Masonf9295742008-07-17 12:54:14 -0400409 cur_trans = root->fs_info->running_transaction;
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000410 if (cur_trans && is_transaction_blocked(cur_trans)) {
Josef Bacik13c5a932011-04-11 15:45:29 -0400411 atomic_inc(&cur_trans->use_count);
Josef Bacika4abeea2011-04-11 17:25:13 -0400412 spin_unlock(&root->fs_info->trans_lock);
Li Zefan72d63ed2011-07-14 03:17:00 +0000413
414 wait_event(root->fs_info->transaction_wait,
Josef Bacik501407a2013-06-10 16:47:23 -0400415 cur_trans->state >= TRANS_STATE_UNBLOCKED ||
416 cur_trans->aborted);
Josef Bacik724e2312013-09-30 11:36:38 -0400417 btrfs_put_transaction(cur_trans);
Josef Bacika4abeea2011-04-11 17:25:13 -0400418 } else {
419 spin_unlock(&root->fs_info->trans_lock);
Chris Masonf9295742008-07-17 12:54:14 -0400420 }
Chris Mason37d1aee2008-07-31 10:48:37 -0400421}
422
Yan, Zhenga22285a2010-05-16 10:48:46 -0400423static int may_wait_transaction(struct btrfs_root *root, int type)
Chris Mason37d1aee2008-07-31 10:48:37 -0400424{
Josef Bacika4abeea2011-04-11 17:25:13 -0400425 if (root->fs_info->log_root_recovering)
426 return 0;
427
428 if (type == TRANS_USERSPACE)
Yan, Zhenga22285a2010-05-16 10:48:46 -0400429 return 1;
Josef Bacika4abeea2011-04-11 17:25:13 -0400430
431 if (type == TRANS_START &&
432 !atomic_read(&root->fs_info->open_ioctl_trans))
433 return 1;
434
Yan, Zhenga22285a2010-05-16 10:48:46 -0400435 return 0;
436}
437
Miao Xie20dd2cb2013-09-25 21:47:45 +0800438static inline bool need_reserve_reloc_root(struct btrfs_root *root)
439{
440 if (!root->fs_info->reloc_ctl ||
Miao Xie27cdeb72014-04-02 19:51:05 +0800441 !test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
Miao Xie20dd2cb2013-09-25 21:47:45 +0800442 root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
443 root->reloc_root)
444 return false;
445
446 return true;
447}
448
Miao Xie08e007d2012-10-16 11:33:38 +0000449static struct btrfs_trans_handle *
Miao Xie0860adf2013-05-15 07:48:27 +0000450start_transaction(struct btrfs_root *root, u64 num_items, unsigned int type,
Miao Xie08e007d2012-10-16 11:33:38 +0000451 enum btrfs_reserve_flush_enum flush)
Yan, Zhenga22285a2010-05-16 10:48:46 -0400452{
453 struct btrfs_trans_handle *h;
454 struct btrfs_transaction *cur_trans;
Josef Bacikb5009942011-06-07 15:07:51 -0400455 u64 num_bytes = 0;
Arne Jansenc5567232011-09-14 15:44:05 +0200456 u64 qgroup_reserved = 0;
Miao Xie20dd2cb2013-09-25 21:47:45 +0800457 bool reloc_reserved = false;
458 int ret;
liuboacce9522011-01-06 19:30:25 +0800459
Filipe Manana46c4e712014-06-24 17:48:28 +0100460 /* Send isn't supposed to start transactions. */
David Sterba2755a0d2014-07-31 00:43:18 +0200461 ASSERT(current->journal_info != BTRFS_SEND_TRANS_STUB);
Filipe Manana46c4e712014-06-24 17:48:28 +0100462
Miao Xie87533c42013-01-29 10:14:48 +0000463 if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state))
liuboacce9522011-01-06 19:30:25 +0800464 return ERR_PTR(-EROFS);
Josef Bacik2a1eb462011-04-13 15:15:59 -0400465
Filipe Manana46c4e712014-06-24 17:48:28 +0100466 if (current->journal_info) {
Miao Xie0860adf2013-05-15 07:48:27 +0000467 WARN_ON(type & TRANS_EXTWRITERS);
Josef Bacik2a1eb462011-04-13 15:15:59 -0400468 h = current->journal_info;
469 h->use_count++;
Miao Xieb7d5b0a2012-11-01 07:32:18 +0000470 WARN_ON(h->use_count > 2);
Josef Bacik2a1eb462011-04-13 15:15:59 -0400471 h->orig_rsv = h->block_rsv;
472 h->block_rsv = NULL;
473 goto got_it;
474 }
Josef Bacikb5009942011-06-07 15:07:51 -0400475
476 /*
477 * Do the reservation before we join the transaction so we can do all
478 * the appropriate flushing if need be.
479 */
480 if (num_items > 0 && root != root->fs_info->chunk_root) {
Arne Jansenc5567232011-09-14 15:44:05 +0200481 if (root->fs_info->quota_enabled &&
482 is_fstree(root->root_key.objectid)) {
David Sterba707e8a02014-06-04 19:22:26 +0200483 qgroup_reserved = num_items * root->nodesize;
Arne Jansenc5567232011-09-14 15:44:05 +0200484 ret = btrfs_qgroup_reserve(root, qgroup_reserved);
485 if (ret)
486 return ERR_PTR(ret);
487 }
488
Josef Bacikb5009942011-06-07 15:07:51 -0400489 num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
Miao Xie20dd2cb2013-09-25 21:47:45 +0800490 /*
491 * Do the reservation for the relocation root creation
492 */
David Sterbaee39b432014-09-30 01:33:33 +0200493 if (need_reserve_reloc_root(root)) {
Miao Xie20dd2cb2013-09-25 21:47:45 +0800494 num_bytes += root->nodesize;
495 reloc_reserved = true;
496 }
497
Miao Xie08e007d2012-10-16 11:33:38 +0000498 ret = btrfs_block_rsv_add(root,
499 &root->fs_info->trans_block_rsv,
500 num_bytes, flush);
Josef Bacikb5009942011-06-07 15:07:51 -0400501 if (ret)
Miao Xie843fcf32013-01-28 12:36:22 +0000502 goto reserve_fail;
Josef Bacikb5009942011-06-07 15:07:51 -0400503 }
Yan, Zhenga22285a2010-05-16 10:48:46 -0400504again:
505 h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
Miao Xie843fcf32013-01-28 12:36:22 +0000506 if (!h) {
507 ret = -ENOMEM;
508 goto alloc_fail;
509 }
Yan, Zhenga22285a2010-05-16 10:48:46 -0400510
Josef Bacik98114652012-09-14 11:22:38 -0400511 /*
512 * If we are JOIN_NOLOCK we're already committing a transaction and
513 * waiting on this guy, so we don't need to do the sb_start_intwrite
514 * because we're already holding a ref. We need this because we could
515 * have raced in and did an fsync() on a file which can kick a commit
516 * and then we deadlock with somebody doing a freeze.
Miao Xie354aa0f2012-09-20 01:54:00 -0600517 *
518 * If we are ATTACH, it means we just want to catch the current
519 * transaction and commit it, so we needn't do sb_start_intwrite().
Josef Bacik98114652012-09-14 11:22:38 -0400520 */
Miao Xie0860adf2013-05-15 07:48:27 +0000521 if (type & __TRANS_FREEZABLE)
Josef Bacik60376ce2012-09-14 10:34:40 -0400522 sb_start_intwrite(root->fs_info->sb);
Jan Karab2b5ef52012-06-12 16:20:45 +0200523
Yan, Zhenga22285a2010-05-16 10:48:46 -0400524 if (may_wait_transaction(root, type))
Chris Mason37d1aee2008-07-31 10:48:37 -0400525 wait_current_trans(root);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400526
Josef Bacika4abeea2011-04-11 17:25:13 -0400527 do {
Miao Xie354aa0f2012-09-20 01:54:00 -0600528 ret = join_transaction(root, type);
Miao Xie178260b2013-02-20 09:16:24 +0000529 if (ret == -EBUSY) {
Josef Bacika4abeea2011-04-11 17:25:13 -0400530 wait_current_trans(root);
Miao Xie178260b2013-02-20 09:16:24 +0000531 if (unlikely(type == TRANS_ATTACH))
532 ret = -ENOENT;
533 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400534 } while (ret == -EBUSY);
535
Tsutomu Itohdb5b4932011-03-23 08:14:16 +0000536 if (ret < 0) {
Miao Xie354aa0f2012-09-20 01:54:00 -0600537 /* We must get the transaction if we are JOIN_NOLOCK. */
538 BUG_ON(type == TRANS_JOIN_NOLOCK);
Miao Xie843fcf32013-01-28 12:36:22 +0000539 goto join_fail;
Tsutomu Itohdb5b4932011-03-23 08:14:16 +0000540 }
Chris Mason0f7d52f2007-04-09 10:42:37 -0400541
Yan, Zhenga22285a2010-05-16 10:48:46 -0400542 cur_trans = root->fs_info->running_transaction;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400543
544 h->transid = cur_trans->transid;
545 h->transaction = cur_trans;
Chris Mason79154b12007-03-22 15:59:16 -0400546 h->blocks_used = 0;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400547 h->bytes_reserved = 0;
Filipe Manana4fbcdf62015-05-20 14:01:54 +0100548 h->chunk_bytes_reserved = 0;
Arne Jansend13603e2011-09-13 11:40:09 +0200549 h->root = root;
Chris Mason56bec292009-03-13 10:10:06 -0400550 h->delayed_ref_updates = 0;
Josef Bacik2a1eb462011-04-13 15:15:59 -0400551 h->use_count = 1;
Josef Bacik0e721102012-06-26 16:13:18 -0400552 h->adding_csums = 0;
Yan, Zhengf0486c62010-05-16 10:46:25 -0400553 h->block_rsv = NULL;
Josef Bacik2a1eb462011-04-13 15:15:59 -0400554 h->orig_rsv = NULL;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100555 h->aborted = 0;
Miao Xie4b824902013-02-20 09:13:32 +0000556 h->qgroup_reserved = 0;
Arne Jansenbed92ea2012-06-28 18:03:02 +0200557 h->delayed_ref_elem.seq = 0;
Miao Xiea698d0752012-09-20 01:51:59 -0600558 h->type = type;
Josef Bacikc6b305a2012-12-18 09:16:16 -0500559 h->allocating_chunk = false;
Filipe Mananad9a05402015-10-03 13:13:13 +0100560 h->can_flush_pending_bgs = true;
Miao Xie20dd2cb2013-09-25 21:47:45 +0800561 h->reloc_reserved = false;
Josef Bacik5039edd2014-01-15 13:34:13 -0500562 h->sync = false;
Arne Jansenbed92ea2012-06-28 18:03:02 +0200563 INIT_LIST_HEAD(&h->qgroup_ref_list);
Josef Bacikea658ba2012-09-11 16:57:25 -0400564 INIT_LIST_HEAD(&h->new_bgs);
Josef Bacik50d9aa92014-11-21 14:52:38 -0500565 INIT_LIST_HEAD(&h->ordered);
Chris Masonb7ec40d2009-03-12 20:12:45 -0400566
Yan, Zhenga22285a2010-05-16 10:48:46 -0400567 smp_mb();
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000568 if (cur_trans->state >= TRANS_STATE_BLOCKED &&
569 may_wait_transaction(root, type)) {
Filipe Mananaabdd2e82014-06-24 17:46:58 +0100570 current->journal_info = h;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400571 btrfs_commit_transaction(h, root);
572 goto again;
573 }
Josef Bacik9ed74f22009-09-11 16:12:44 -0400574
Josef Bacikb5009942011-06-07 15:07:51 -0400575 if (num_bytes) {
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500576 trace_btrfs_space_reservation(root->fs_info, "transaction",
Liu Bo2bcc0322012-03-29 09:57:44 -0400577 h->transid, num_bytes, 1);
Josef Bacikb5009942011-06-07 15:07:51 -0400578 h->block_rsv = &root->fs_info->trans_block_rsv;
579 h->bytes_reserved = num_bytes;
Miao Xie20dd2cb2013-09-25 21:47:45 +0800580 h->reloc_reserved = reloc_reserved;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400581 }
Miao Xie4b824902013-02-20 09:13:32 +0000582 h->qgroup_reserved = qgroup_reserved;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400583
Josef Bacik2a1eb462011-04-13 15:15:59 -0400584got_it:
Josef Bacika4abeea2011-04-11 17:25:13 -0400585 btrfs_record_root_in_trans(h, root);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400586
587 if (!current->journal_info && type != TRANS_USERSPACE)
588 current->journal_info = h;
Chris Mason79154b12007-03-22 15:59:16 -0400589 return h;
Miao Xie843fcf32013-01-28 12:36:22 +0000590
591join_fail:
Miao Xie0860adf2013-05-15 07:48:27 +0000592 if (type & __TRANS_FREEZABLE)
Miao Xie843fcf32013-01-28 12:36:22 +0000593 sb_end_intwrite(root->fs_info->sb);
594 kmem_cache_free(btrfs_trans_handle_cachep, h);
595alloc_fail:
596 if (num_bytes)
597 btrfs_block_rsv_release(root, &root->fs_info->trans_block_rsv,
598 num_bytes);
599reserve_fail:
600 if (qgroup_reserved)
601 btrfs_qgroup_free(root, qgroup_reserved);
602 return ERR_PTR(ret);
Chris Mason79154b12007-03-22 15:59:16 -0400603}
604
Chris Masonf9295742008-07-17 12:54:14 -0400605struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
Yan, Zhenga22285a2010-05-16 10:48:46 -0400606 int num_items)
Chris Masonf9295742008-07-17 12:54:14 -0400607{
Miao Xie08e007d2012-10-16 11:33:38 +0000608 return start_transaction(root, num_items, TRANS_START,
609 BTRFS_RESERVE_FLUSH_ALL);
Chris Masonf9295742008-07-17 12:54:14 -0400610}
Miao Xie8407aa42012-09-07 01:43:32 -0600611
Miao Xie08e007d2012-10-16 11:33:38 +0000612struct btrfs_trans_handle *btrfs_start_transaction_lflush(
Miao Xie8407aa42012-09-07 01:43:32 -0600613 struct btrfs_root *root, int num_items)
614{
Miao Xie08e007d2012-10-16 11:33:38 +0000615 return start_transaction(root, num_items, TRANS_START,
616 BTRFS_RESERVE_FLUSH_LIMIT);
Miao Xie8407aa42012-09-07 01:43:32 -0600617}
618
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400619struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
Chris Masonf9295742008-07-17 12:54:14 -0400620{
Miao Xie8407aa42012-09-07 01:43:32 -0600621 return start_transaction(root, 0, TRANS_JOIN, 0);
Chris Masonf9295742008-07-17 12:54:14 -0400622}
623
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400624struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
Josef Bacik0af3d002010-06-21 14:48:16 -0400625{
Miao Xie8407aa42012-09-07 01:43:32 -0600626 return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 0);
Josef Bacik0af3d002010-06-21 14:48:16 -0400627}
628
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400629struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
Sage Weil9ca9ee02008-08-04 10:41:27 -0400630{
Miao Xie8407aa42012-09-07 01:43:32 -0600631 return start_transaction(root, 0, TRANS_USERSPACE, 0);
Sage Weil9ca9ee02008-08-04 10:41:27 -0400632}
633
Miao Xied4edf392013-02-20 09:17:06 +0000634/*
635 * btrfs_attach_transaction() - catch the running transaction
636 *
637 * It is used when we want to commit the current the transaction, but
638 * don't want to start a new one.
639 *
640 * Note: If this function return -ENOENT, it just means there is no
641 * running transaction. But it is possible that the inactive transaction
642 * is still in the memory, not fully on disk. If you hope there is no
643 * inactive transaction in the fs when -ENOENT is returned, you should
644 * invoke
645 * btrfs_attach_transaction_barrier()
646 */
Miao Xie354aa0f2012-09-20 01:54:00 -0600647struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root)
Josef Bacik60376ce2012-09-14 10:34:40 -0400648{
Miao Xie354aa0f2012-09-20 01:54:00 -0600649 return start_transaction(root, 0, TRANS_ATTACH, 0);
Josef Bacik60376ce2012-09-14 10:34:40 -0400650}
651
Miao Xied4edf392013-02-20 09:17:06 +0000652/*
Wang Sheng-Hui90b6d282013-06-14 16:21:24 +0800653 * btrfs_attach_transaction_barrier() - catch the running transaction
Miao Xied4edf392013-02-20 09:17:06 +0000654 *
655 * It is similar to the above function, the differentia is this one
656 * will wait for all the inactive transactions until they fully
657 * complete.
658 */
659struct btrfs_trans_handle *
660btrfs_attach_transaction_barrier(struct btrfs_root *root)
661{
662 struct btrfs_trans_handle *trans;
663
664 trans = start_transaction(root, 0, TRANS_ATTACH, 0);
665 if (IS_ERR(trans) && PTR_ERR(trans) == -ENOENT)
666 btrfs_wait_for_commit(root, 0);
667
668 return trans;
669}
670
Chris Masond352ac62008-09-29 15:18:18 -0400671/* wait for a transaction commit to be fully complete */
Li Zefanb9c83002011-07-14 03:17:14 +0000672static noinline void wait_for_commit(struct btrfs_root *root,
Chris Mason89ce8a62008-06-25 16:01:31 -0400673 struct btrfs_transaction *commit)
674{
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000675 wait_event(commit->commit_wait, commit->state == TRANS_STATE_COMPLETED);
Chris Mason89ce8a62008-06-25 16:01:31 -0400676}
677
Sage Weil46204592010-10-29 15:41:32 -0400678int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
679{
680 struct btrfs_transaction *cur_trans = NULL, *t;
Miao Xie8cd28072012-11-26 08:42:07 +0000681 int ret = 0;
Sage Weil46204592010-10-29 15:41:32 -0400682
Sage Weil46204592010-10-29 15:41:32 -0400683 if (transid) {
684 if (transid <= root->fs_info->last_trans_committed)
Josef Bacika4abeea2011-04-11 17:25:13 -0400685 goto out;
Sage Weil46204592010-10-29 15:41:32 -0400686
687 /* find specified transaction */
Josef Bacika4abeea2011-04-11 17:25:13 -0400688 spin_lock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400689 list_for_each_entry(t, &root->fs_info->trans_list, list) {
690 if (t->transid == transid) {
691 cur_trans = t;
Josef Bacika4abeea2011-04-11 17:25:13 -0400692 atomic_inc(&cur_trans->use_count);
Miao Xie8cd28072012-11-26 08:42:07 +0000693 ret = 0;
Sage Weil46204592010-10-29 15:41:32 -0400694 break;
695 }
Miao Xie8cd28072012-11-26 08:42:07 +0000696 if (t->transid > transid) {
697 ret = 0;
Sage Weil46204592010-10-29 15:41:32 -0400698 break;
Miao Xie8cd28072012-11-26 08:42:07 +0000699 }
Sage Weil46204592010-10-29 15:41:32 -0400700 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400701 spin_unlock(&root->fs_info->trans_lock);
Sage Weil42383022014-09-26 08:30:06 -0700702
703 /*
704 * The specified transaction doesn't exist, or we
705 * raced with btrfs_commit_transaction
706 */
707 if (!cur_trans) {
708 if (transid > root->fs_info->last_trans_committed)
709 ret = -EINVAL;
Miao Xie8cd28072012-11-26 08:42:07 +0000710 goto out;
Sage Weil42383022014-09-26 08:30:06 -0700711 }
Sage Weil46204592010-10-29 15:41:32 -0400712 } else {
713 /* find newest transaction that is committing | committed */
Josef Bacika4abeea2011-04-11 17:25:13 -0400714 spin_lock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400715 list_for_each_entry_reverse(t, &root->fs_info->trans_list,
716 list) {
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000717 if (t->state >= TRANS_STATE_COMMIT_START) {
718 if (t->state == TRANS_STATE_COMPLETED)
Josef Bacik3473f3c2011-06-09 10:15:17 -0400719 break;
Sage Weil46204592010-10-29 15:41:32 -0400720 cur_trans = t;
Josef Bacika4abeea2011-04-11 17:25:13 -0400721 atomic_inc(&cur_trans->use_count);
Sage Weil46204592010-10-29 15:41:32 -0400722 break;
723 }
724 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400725 spin_unlock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400726 if (!cur_trans)
Josef Bacika4abeea2011-04-11 17:25:13 -0400727 goto out; /* nothing committing|committed */
Sage Weil46204592010-10-29 15:41:32 -0400728 }
729
Sage Weil46204592010-10-29 15:41:32 -0400730 wait_for_commit(root, cur_trans);
Josef Bacik724e2312013-09-30 11:36:38 -0400731 btrfs_put_transaction(cur_trans);
Josef Bacika4abeea2011-04-11 17:25:13 -0400732out:
Sage Weil46204592010-10-29 15:41:32 -0400733 return ret;
734}
735
Chris Mason37d1aee2008-07-31 10:48:37 -0400736void btrfs_throttle(struct btrfs_root *root)
737{
Josef Bacika4abeea2011-04-11 17:25:13 -0400738 if (!atomic_read(&root->fs_info->open_ioctl_trans))
Sage Weil9ca9ee02008-08-04 10:41:27 -0400739 wait_current_trans(root);
Chris Mason37d1aee2008-07-31 10:48:37 -0400740}
741
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400742static int should_end_transaction(struct btrfs_trans_handle *trans,
743 struct btrfs_root *root)
744{
Josef Bacik1be41b72013-06-12 13:56:06 -0400745 if (root->fs_info->global_block_rsv.space_info->full &&
Josef Bacik0a2b2a82014-01-23 10:54:11 -0500746 btrfs_check_space_for_delayed_refs(trans, root))
Josef Bacik1be41b72013-06-12 13:56:06 -0400747 return 1;
Josef Bacik36ba0222011-10-18 12:15:48 -0400748
Josef Bacik1be41b72013-06-12 13:56:06 -0400749 return !!btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400750}
751
752int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
753 struct btrfs_root *root)
754{
755 struct btrfs_transaction *cur_trans = trans->transaction;
756 int updates;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100757 int err;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400758
Josef Bacika4abeea2011-04-11 17:25:13 -0400759 smp_mb();
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000760 if (cur_trans->state >= TRANS_STATE_BLOCKED ||
761 cur_trans->delayed_refs.flushing)
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400762 return 1;
763
764 updates = trans->delayed_ref_updates;
765 trans->delayed_ref_updates = 0;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100766 if (updates) {
Chris Mason28ed1342014-12-17 09:41:04 -0800767 err = btrfs_run_delayed_refs(trans, root, updates * 2);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100768 if (err) /* Error code will also eval true */
769 return err;
770 }
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400771
772 return should_end_transaction(trans, root);
773}
774
Chris Mason89ce8a62008-06-25 16:01:31 -0400775static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
Miao Xiea698d0752012-09-20 01:51:59 -0600776 struct btrfs_root *root, int throttle)
Chris Mason79154b12007-03-22 15:59:16 -0400777{
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400778 struct btrfs_transaction *cur_trans = trans->transaction;
Chris Masonab78c842008-07-29 16:15:18 -0400779 struct btrfs_fs_info *info = root->fs_info;
Josef Bacik1be41b72013-06-12 13:56:06 -0400780 unsigned long cur = trans->delayed_ref_updates;
Miao Xiea698d0752012-09-20 01:51:59 -0600781 int lock = (trans->type != TRANS_JOIN_NOLOCK);
Dave Jones4edc2ca2012-04-12 16:03:56 -0400782 int err = 0;
Chris Masona79b7d42014-05-22 16:18:52 -0700783 int must_run_delayed_refs = 0;
Chris Masond6e4a422007-04-06 15:37:36 -0400784
Josef Bacik3bbb24b2014-03-06 19:01:07 -0500785 if (trans->use_count > 1) {
786 trans->use_count--;
Josef Bacik2a1eb462011-04-13 15:15:59 -0400787 trans->block_rsv = trans->orig_rsv;
788 return 0;
789 }
790
Josef Bacikb24e03d2011-10-14 14:40:17 -0400791 btrfs_trans_release_metadata(trans, root);
Josef Bacik4c13d752011-08-30 11:31:29 -0400792 trans->block_rsv = NULL;
Arne Jansenc5567232011-09-14 15:44:05 +0200793
Josef Bacikea658ba2012-09-11 16:57:25 -0400794 if (!list_empty(&trans->new_bgs))
795 btrfs_create_pending_block_groups(trans, root);
796
Josef Bacik50d9aa92014-11-21 14:52:38 -0500797 if (!list_empty(&trans->ordered)) {
798 spin_lock(&info->trans_lock);
Filipe Mananad3efe082015-07-03 20:30:34 +0100799 list_splice_init(&trans->ordered, &cur_trans->pending_ordered);
Josef Bacik50d9aa92014-11-21 14:52:38 -0500800 spin_unlock(&info->trans_lock);
801 }
802
Josef Bacik1be41b72013-06-12 13:56:06 -0400803 trans->delayed_ref_updates = 0;
Chris Masona79b7d42014-05-22 16:18:52 -0700804 if (!trans->sync) {
805 must_run_delayed_refs =
806 btrfs_should_throttle_delayed_refs(trans, root);
Josef Bacik0a2b2a82014-01-23 10:54:11 -0500807 cur = max_t(unsigned long, cur, 32);
Chris Masona79b7d42014-05-22 16:18:52 -0700808
809 /*
810 * don't make the caller wait if they are from a NOLOCK
811 * or ATTACH transaction, it will deadlock with commit
812 */
813 if (must_run_delayed_refs == 1 &&
814 (trans->type & (__TRANS_JOIN_NOLOCK | __TRANS_ATTACH)))
815 must_run_delayed_refs = 2;
Chris Mason56bec292009-03-13 10:10:06 -0400816 }
Chris Masonbb721702013-01-29 18:44:12 -0500817
Josef Bacikfcebe452014-05-13 17:30:47 -0700818 if (trans->qgroup_reserved) {
819 /*
820 * the same root has to be passed here between start_transaction
821 * and end_transaction. Subvolume quota depends on this.
822 */
823 btrfs_qgroup_free(trans->root, trans->qgroup_reserved);
824 trans->qgroup_reserved = 0;
825 }
826
Josef Bacik0e721102012-06-26 16:13:18 -0400827 btrfs_trans_release_metadata(trans, root);
828 trans->block_rsv = NULL;
Chris Mason56bec292009-03-13 10:10:06 -0400829
Josef Bacikea658ba2012-09-11 16:57:25 -0400830 if (!list_empty(&trans->new_bgs))
831 btrfs_create_pending_block_groups(trans, root);
832
Filipe Manana4fbcdf62015-05-20 14:01:54 +0100833 btrfs_trans_release_chunk_metadata(trans);
834
Josef Bacika4abeea2011-04-11 17:25:13 -0400835 if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000836 should_end_transaction(trans, root) &&
837 ACCESS_ONCE(cur_trans->state) == TRANS_STATE_RUNNING) {
838 spin_lock(&info->trans_lock);
839 if (cur_trans->state == TRANS_STATE_RUNNING)
840 cur_trans->state = TRANS_STATE_BLOCKED;
841 spin_unlock(&info->trans_lock);
Josef Bacika4abeea2011-04-11 17:25:13 -0400842 }
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400843
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000844 if (lock && ACCESS_ONCE(cur_trans->state) == TRANS_STATE_BLOCKED) {
Josef Bacik3bbb24b2014-03-06 19:01:07 -0500845 if (throttle)
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400846 return btrfs_commit_transaction(trans, root);
Josef Bacik3bbb24b2014-03-06 19:01:07 -0500847 else
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400848 wake_up_process(info->transaction_kthread);
849 }
850
Miao Xie0860adf2013-05-15 07:48:27 +0000851 if (trans->type & __TRANS_FREEZABLE)
Josef Bacik98114652012-09-14 11:22:38 -0400852 sb_end_intwrite(root->fs_info->sb);
Josef Bacik6df78812012-09-05 08:08:30 -0600853
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400854 WARN_ON(cur_trans != info->running_transaction);
Josef Bacik13c5a932011-04-11 15:45:29 -0400855 WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
856 atomic_dec(&cur_trans->num_writers);
Miao Xie0860adf2013-05-15 07:48:27 +0000857 extwriter_counter_dec(cur_trans, trans->type);
Chris Mason89ce8a62008-06-25 16:01:31 -0400858
Sage Weil99d16cb2010-10-29 15:37:34 -0400859 smp_mb();
Chris Mason79154b12007-03-22 15:59:16 -0400860 if (waitqueue_active(&cur_trans->writer_wait))
861 wake_up(&cur_trans->writer_wait);
Josef Bacik724e2312013-09-30 11:36:38 -0400862 btrfs_put_transaction(cur_trans);
Josef Bacik9ed74f22009-09-11 16:12:44 -0400863
864 if (current->journal_info == trans)
865 current->journal_info = NULL;
Chris Masonab78c842008-07-29 16:15:18 -0400866
Yan, Zheng24bbcf02009-11-12 09:36:34 +0000867 if (throttle)
868 btrfs_run_delayed_iputs(root);
869
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100870 if (trans->aborted ||
Josef Bacik4e121c02013-09-27 16:32:39 -0400871 test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
872 wake_up_process(info->transaction_kthread);
Dave Jones4edc2ca2012-04-12 16:03:56 -0400873 err = -EIO;
Josef Bacik4e121c02013-09-27 16:32:39 -0400874 }
Jan Schmidtedf39272012-06-28 18:04:55 +0200875 assert_qgroups_uptodate(trans);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100876
Dave Jones4edc2ca2012-04-12 16:03:56 -0400877 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Chris Masona79b7d42014-05-22 16:18:52 -0700878 if (must_run_delayed_refs) {
879 btrfs_async_run_delayed_refs(root, cur,
880 must_run_delayed_refs == 1);
881 }
Dave Jones4edc2ca2012-04-12 16:03:56 -0400882 return err;
Chris Mason79154b12007-03-22 15:59:16 -0400883}
884
Chris Mason89ce8a62008-06-25 16:01:31 -0400885int btrfs_end_transaction(struct btrfs_trans_handle *trans,
886 struct btrfs_root *root)
887{
Wang Shilong98ad43be2013-04-14 14:08:49 +0000888 return __btrfs_end_transaction(trans, root, 0);
Chris Mason89ce8a62008-06-25 16:01:31 -0400889}
890
891int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
892 struct btrfs_root *root)
893{
Wang Shilong98ad43be2013-04-14 14:08:49 +0000894 return __btrfs_end_transaction(trans, root, 1);
Miao Xie16cdcec2011-04-22 18:12:22 +0800895}
896
Chris Masond352ac62008-09-29 15:18:18 -0400897/*
898 * when btree blocks are allocated, they have some corresponding bits set for
899 * them in one of two extent_io trees. This is used to make sure all of
Chris Mason690587d2009-10-13 13:29:19 -0400900 * those extents are sent to disk but does not wait on them
Chris Masond352ac62008-09-29 15:18:18 -0400901 */
Chris Mason690587d2009-10-13 13:29:19 -0400902int btrfs_write_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000903 struct extent_io_tree *dirty_pages, int mark)
Chris Mason79154b12007-03-22 15:59:16 -0400904{
Chris Mason777e6bd2008-08-15 15:34:15 -0400905 int err = 0;
Chris Mason7c4452b2007-04-28 09:29:35 -0400906 int werr = 0;
Josef Bacik17283662011-09-26 13:58:47 -0400907 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
Josef Bacike6138872012-09-27 17:07:30 -0400908 struct extent_state *cached_state = NULL;
Chris Mason777e6bd2008-08-15 15:34:15 -0400909 u64 start = 0;
Chris Mason5f39d392007-10-15 16:14:19 -0400910 u64 end;
Chris Mason7c4452b2007-04-28 09:29:35 -0400911
Josef Bacik17283662011-09-26 13:58:47 -0400912 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
Josef Bacike6138872012-09-27 17:07:30 -0400913 mark, &cached_state)) {
Filipe Manana663dfbb2014-10-13 12:28:37 +0100914 bool wait_writeback = false;
915
916 err = convert_extent_bit(dirty_pages, start, end,
917 EXTENT_NEED_WAIT,
918 mark, &cached_state, GFP_NOFS);
919 /*
920 * convert_extent_bit can return -ENOMEM, which is most of the
921 * time a temporary error. So when it happens, ignore the error
922 * and wait for writeback of this range to finish - because we
923 * failed to set the bit EXTENT_NEED_WAIT for the range, a call
924 * to btrfs_wait_marked_extents() would not know that writeback
925 * for this range started and therefore wouldn't wait for it to
926 * finish - we don't want to commit a superblock that points to
927 * btree nodes/leafs for which writeback hasn't finished yet
928 * (and without errors).
929 * We cleanup any entries left in the io tree when committing
930 * the transaction (through clear_btree_io_tree()).
931 */
932 if (err == -ENOMEM) {
933 err = 0;
934 wait_writeback = true;
935 }
936 if (!err)
937 err = filemap_fdatawrite_range(mapping, start, end);
Josef Bacik17283662011-09-26 13:58:47 -0400938 if (err)
939 werr = err;
Filipe Manana663dfbb2014-10-13 12:28:37 +0100940 else if (wait_writeback)
941 werr = filemap_fdatawait_range(mapping, start, end);
Filipe Mananae38e2ed2014-10-13 12:28:38 +0100942 free_extent_state(cached_state);
Filipe Manana663dfbb2014-10-13 12:28:37 +0100943 cached_state = NULL;
Josef Bacik17283662011-09-26 13:58:47 -0400944 cond_resched();
945 start = end + 1;
Chris Mason7c4452b2007-04-28 09:29:35 -0400946 }
Chris Mason690587d2009-10-13 13:29:19 -0400947 return werr;
948}
949
950/*
951 * when btree blocks are allocated, they have some corresponding bits set for
952 * them in one of two extent_io trees. This is used to make sure all of
953 * those extents are on disk for transaction or log commit. We wait
954 * on all the pages and clear them from the dirty pages state tree
955 */
956int btrfs_wait_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000957 struct extent_io_tree *dirty_pages, int mark)
Chris Mason690587d2009-10-13 13:29:19 -0400958{
Chris Mason690587d2009-10-13 13:29:19 -0400959 int err = 0;
960 int werr = 0;
Josef Bacik17283662011-09-26 13:58:47 -0400961 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
Josef Bacike6138872012-09-27 17:07:30 -0400962 struct extent_state *cached_state = NULL;
Chris Mason690587d2009-10-13 13:29:19 -0400963 u64 start = 0;
964 u64 end;
Filipe Manana656f30d2014-09-26 12:25:56 +0100965 struct btrfs_inode *btree_ino = BTRFS_I(root->fs_info->btree_inode);
966 bool errors = false;
Chris Mason690587d2009-10-13 13:29:19 -0400967
Josef Bacik17283662011-09-26 13:58:47 -0400968 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
Josef Bacike6138872012-09-27 17:07:30 -0400969 EXTENT_NEED_WAIT, &cached_state)) {
Filipe Manana663dfbb2014-10-13 12:28:37 +0100970 /*
971 * Ignore -ENOMEM errors returned by clear_extent_bit().
972 * When committing the transaction, we'll remove any entries
973 * left in the io tree. For a log commit, we don't remove them
974 * after committing the log because the tree can be accessed
975 * concurrently - we do it only at transaction commit time when
976 * it's safe to do it (through clear_btree_io_tree()).
977 */
978 err = clear_extent_bit(dirty_pages, start, end,
979 EXTENT_NEED_WAIT,
980 0, 0, &cached_state, GFP_NOFS);
981 if (err == -ENOMEM)
982 err = 0;
983 if (!err)
984 err = filemap_fdatawait_range(mapping, start, end);
Josef Bacik17283662011-09-26 13:58:47 -0400985 if (err)
986 werr = err;
Filipe Mananae38e2ed2014-10-13 12:28:38 +0100987 free_extent_state(cached_state);
988 cached_state = NULL;
Josef Bacik17283662011-09-26 13:58:47 -0400989 cond_resched();
990 start = end + 1;
Chris Mason777e6bd2008-08-15 15:34:15 -0400991 }
Chris Mason7c4452b2007-04-28 09:29:35 -0400992 if (err)
993 werr = err;
Filipe Manana656f30d2014-09-26 12:25:56 +0100994
995 if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
996 if ((mark & EXTENT_DIRTY) &&
997 test_and_clear_bit(BTRFS_INODE_BTREE_LOG1_ERR,
998 &btree_ino->runtime_flags))
999 errors = true;
1000
1001 if ((mark & EXTENT_NEW) &&
1002 test_and_clear_bit(BTRFS_INODE_BTREE_LOG2_ERR,
1003 &btree_ino->runtime_flags))
1004 errors = true;
1005 } else {
1006 if (test_and_clear_bit(BTRFS_INODE_BTREE_ERR,
1007 &btree_ino->runtime_flags))
1008 errors = true;
1009 }
1010
1011 if (errors && !werr)
1012 werr = -EIO;
1013
Chris Mason7c4452b2007-04-28 09:29:35 -04001014 return werr;
Chris Mason79154b12007-03-22 15:59:16 -04001015}
1016
Chris Mason690587d2009-10-13 13:29:19 -04001017/*
1018 * when btree blocks are allocated, they have some corresponding bits set for
1019 * them in one of two extent_io trees. This is used to make sure all of
1020 * those extents are on disk for transaction or log commit
1021 */
Sergei Trofimovich171170c2013-08-14 23:27:46 +03001022static int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +00001023 struct extent_io_tree *dirty_pages, int mark)
Chris Mason690587d2009-10-13 13:29:19 -04001024{
1025 int ret;
1026 int ret2;
Miao Xiec6adc9c2013-05-28 10:05:39 +00001027 struct blk_plug plug;
Chris Mason690587d2009-10-13 13:29:19 -04001028
Miao Xiec6adc9c2013-05-28 10:05:39 +00001029 blk_start_plug(&plug);
Yan, Zheng8cef4e12009-11-12 09:33:26 +00001030 ret = btrfs_write_marked_extents(root, dirty_pages, mark);
Miao Xiec6adc9c2013-05-28 10:05:39 +00001031 blk_finish_plug(&plug);
Yan, Zheng8cef4e12009-11-12 09:33:26 +00001032 ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
Chris Masonbf0da8c2011-11-04 12:29:37 -04001033
1034 if (ret)
1035 return ret;
1036 if (ret2)
1037 return ret2;
1038 return 0;
Chris Mason690587d2009-10-13 13:29:19 -04001039}
1040
Filipe Manana663dfbb2014-10-13 12:28:37 +01001041static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
Chris Masond0c803c2008-09-11 16:17:57 -04001042 struct btrfs_root *root)
1043{
Filipe Manana663dfbb2014-10-13 12:28:37 +01001044 int ret;
1045
1046 ret = btrfs_write_and_wait_marked_extents(root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +00001047 &trans->transaction->dirty_pages,
1048 EXTENT_DIRTY);
Filipe Manana663dfbb2014-10-13 12:28:37 +01001049 clear_btree_io_tree(&trans->transaction->dirty_pages);
1050
1051 return ret;
Chris Masond0c803c2008-09-11 16:17:57 -04001052}
1053
Chris Masond352ac62008-09-29 15:18:18 -04001054/*
1055 * this is used to update the root pointer in the tree of tree roots.
1056 *
1057 * But, in the case of the extent allocation tree, updating the root
1058 * pointer may allocate blocks which may change the root of the extent
1059 * allocation tree.
1060 *
1061 * So, this loops and repeats and makes sure the cowonly root didn't
1062 * change while the root pointer was being updated in the metadata.
1063 */
Chris Mason0b86a832008-03-24 15:01:56 -04001064static int update_cowonly_root(struct btrfs_trans_handle *trans,
1065 struct btrfs_root *root)
1066{
1067 int ret;
1068 u64 old_root_bytenr;
Yan, Zheng86b9f2e2009-11-12 09:36:50 +00001069 u64 old_root_used;
Chris Mason0b86a832008-03-24 15:01:56 -04001070 struct btrfs_root *tree_root = root->fs_info->tree_root;
1071
Yan, Zheng86b9f2e2009-11-12 09:36:50 +00001072 old_root_used = btrfs_root_used(&root->root_item);
Chris Mason56bec292009-03-13 10:10:06 -04001073
Chris Masond3977122009-01-05 21:25:51 -05001074 while (1) {
Chris Mason0b86a832008-03-24 15:01:56 -04001075 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
Yan, Zheng86b9f2e2009-11-12 09:36:50 +00001076 if (old_root_bytenr == root->node->start &&
Josef Bacikea526d12015-03-13 16:40:45 -04001077 old_root_used == btrfs_root_used(&root->root_item))
Chris Mason0b86a832008-03-24 15:01:56 -04001078 break;
Chris Mason87ef2bb2008-10-30 11:23:27 -04001079
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001080 btrfs_set_root_node(&root->root_item, root->node);
Chris Mason0b86a832008-03-24 15:01:56 -04001081 ret = btrfs_update_root(trans, tree_root,
1082 &root->root_key,
1083 &root->root_item);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001084 if (ret)
1085 return ret;
Chris Mason56bec292009-03-13 10:10:06 -04001086
Yan, Zheng86b9f2e2009-11-12 09:36:50 +00001087 old_root_used = btrfs_root_used(&root->root_item);
Chris Mason0b86a832008-03-24 15:01:56 -04001088 }
Yan Zheng276e6802009-07-30 09:40:40 -04001089
Chris Mason0b86a832008-03-24 15:01:56 -04001090 return 0;
1091}
1092
Chris Masond352ac62008-09-29 15:18:18 -04001093/*
1094 * update all the cowonly tree roots on disk
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001095 *
1096 * The error handling in this function may not be obvious. Any of the
1097 * failures will cause the file system to go offline. We still need
1098 * to clean up the delayed refs.
Chris Masond352ac62008-09-29 15:18:18 -04001099 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001100static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
1101 struct btrfs_root *root)
Chris Mason79154b12007-03-22 15:59:16 -04001102{
Chris Mason79154b12007-03-22 15:59:16 -04001103 struct btrfs_fs_info *fs_info = root->fs_info;
Josef Bacikea526d12015-03-13 16:40:45 -04001104 struct list_head *dirty_bgs = &trans->transaction->dirty_bgs;
Chris Mason1bbc6212015-04-06 12:46:08 -07001105 struct list_head *io_bgs = &trans->transaction->io_bgs;
Chris Mason0b86a832008-03-24 15:01:56 -04001106 struct list_head *next;
Yan Zheng84234f32008-10-29 14:49:05 -04001107 struct extent_buffer *eb;
Chris Mason56bec292009-03-13 10:10:06 -04001108 int ret;
Yan Zheng84234f32008-10-29 14:49:05 -04001109
1110 eb = btrfs_lock_root_node(fs_info->tree_root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001111 ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,
1112 0, &eb);
Yan Zheng84234f32008-10-29 14:49:05 -04001113 btrfs_tree_unlock(eb);
1114 free_extent_buffer(eb);
Chris Mason79154b12007-03-22 15:59:16 -04001115
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001116 if (ret)
1117 return ret;
1118
Chris Mason56bec292009-03-13 10:10:06 -04001119 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001120 if (ret)
1121 return ret;
Chris Mason87ef2bb2008-10-30 11:23:27 -04001122
Stefan Behrens733f4fb2012-05-25 16:06:10 +02001123 ret = btrfs_run_dev_stats(trans, root->fs_info);
Josef Bacikc16ce192013-09-27 16:38:20 -04001124 if (ret)
1125 return ret;
Stefan Behrens8dabb742012-11-06 13:15:27 +01001126 ret = btrfs_run_dev_replace(trans, root->fs_info);
Josef Bacikc16ce192013-09-27 16:38:20 -04001127 if (ret)
1128 return ret;
Jan Schmidt546adb02012-06-14 16:37:44 +02001129 ret = btrfs_run_qgroups(trans, root->fs_info);
Josef Bacikc16ce192013-09-27 16:38:20 -04001130 if (ret)
1131 return ret;
Jan Schmidt546adb02012-06-14 16:37:44 +02001132
Josef Bacikdcdf7f62015-03-02 16:37:31 -05001133 ret = btrfs_setup_space_cache(trans, root);
1134 if (ret)
1135 return ret;
1136
Jan Schmidt546adb02012-06-14 16:37:44 +02001137 /* run_qgroups might have added some more refs */
1138 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Josef Bacikc16ce192013-09-27 16:38:20 -04001139 if (ret)
1140 return ret;
Josef Bacikea526d12015-03-13 16:40:45 -04001141again:
Chris Masond3977122009-01-05 21:25:51 -05001142 while (!list_empty(&fs_info->dirty_cowonly_roots)) {
Chris Mason0b86a832008-03-24 15:01:56 -04001143 next = fs_info->dirty_cowonly_roots.next;
1144 list_del_init(next);
1145 root = list_entry(next, struct btrfs_root, dirty_list);
Josef Bacike7070be2014-12-16 08:54:43 -08001146 clear_bit(BTRFS_ROOT_DIRTY, &root->state);
Chris Mason87ef2bb2008-10-30 11:23:27 -04001147
Josef Bacik9e351cc2014-03-13 15:42:13 -04001148 if (root != fs_info->extent_root)
1149 list_add_tail(&root->dirty_list,
1150 &trans->transaction->switch_commits);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001151 ret = update_cowonly_root(trans, root);
1152 if (ret)
1153 return ret;
Josef Bacikea526d12015-03-13 16:40:45 -04001154 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1155 if (ret)
1156 return ret;
Chris Mason79154b12007-03-22 15:59:16 -04001157 }
Yan Zheng276e6802009-07-30 09:40:40 -04001158
Chris Mason1bbc6212015-04-06 12:46:08 -07001159 while (!list_empty(dirty_bgs) || !list_empty(io_bgs)) {
Josef Bacikea526d12015-03-13 16:40:45 -04001160 ret = btrfs_write_dirty_block_groups(trans, root);
1161 if (ret)
1162 return ret;
1163 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1164 if (ret)
1165 return ret;
1166 }
1167
1168 if (!list_empty(&fs_info->dirty_cowonly_roots))
1169 goto again;
1170
Josef Bacik9e351cc2014-03-13 15:42:13 -04001171 list_add_tail(&fs_info->extent_root->dirty_list,
1172 &trans->transaction->switch_commits);
Stefan Behrens8dabb742012-11-06 13:15:27 +01001173 btrfs_after_dev_replace_commit(fs_info);
1174
Chris Mason79154b12007-03-22 15:59:16 -04001175 return 0;
1176}
1177
Chris Masond352ac62008-09-29 15:18:18 -04001178/*
1179 * dead roots are old snapshots that need to be deleted. This allocates
1180 * a dirty root struct and adds it into the list of dead roots that need to
1181 * be deleted
1182 */
Josef Bacikcfad3922013-07-25 15:11:47 -04001183void btrfs_add_dead_root(struct btrfs_root *root)
Chris Mason5eda7b52007-06-22 14:16:25 -04001184{
Josef Bacika4abeea2011-04-11 17:25:13 -04001185 spin_lock(&root->fs_info->trans_lock);
Josef Bacikcfad3922013-07-25 15:11:47 -04001186 if (list_empty(&root->root_list))
1187 list_add_tail(&root->root_list, &root->fs_info->dead_roots);
Josef Bacika4abeea2011-04-11 17:25:13 -04001188 spin_unlock(&root->fs_info->trans_lock);
Chris Mason5eda7b52007-06-22 14:16:25 -04001189}
1190
Chris Masond352ac62008-09-29 15:18:18 -04001191/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001192 * update all the cowonly tree roots on disk
Chris Masond352ac62008-09-29 15:18:18 -04001193 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001194static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
1195 struct btrfs_root *root)
Chris Mason0f7d52f2007-04-09 10:42:37 -04001196{
Chris Mason0f7d52f2007-04-09 10:42:37 -04001197 struct btrfs_root *gang[8];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001198 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Mason0f7d52f2007-04-09 10:42:37 -04001199 int i;
1200 int ret;
Chris Mason54aa1f42007-06-22 14:16:25 -04001201 int err = 0;
1202
Josef Bacika4abeea2011-04-11 17:25:13 -04001203 spin_lock(&fs_info->fs_roots_radix_lock);
Chris Masond3977122009-01-05 21:25:51 -05001204 while (1) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001205 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
1206 (void **)gang, 0,
Chris Mason0f7d52f2007-04-09 10:42:37 -04001207 ARRAY_SIZE(gang),
1208 BTRFS_ROOT_TRANS_TAG);
1209 if (ret == 0)
1210 break;
1211 for (i = 0; i < ret; i++) {
1212 root = gang[i];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001213 radix_tree_tag_clear(&fs_info->fs_roots_radix,
1214 (unsigned long)root->root_key.objectid,
1215 BTRFS_ROOT_TRANS_TAG);
Josef Bacika4abeea2011-04-11 17:25:13 -04001216 spin_unlock(&fs_info->fs_roots_radix_lock);
Yan Zheng31153d82008-07-28 15:32:19 -04001217
Chris Masone02119d2008-09-05 16:13:11 -04001218 btrfs_free_log(trans, root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001219 btrfs_update_reloc_root(trans, root);
Yan, Zhengd68fc572010-05-16 10:49:58 -04001220 btrfs_orphan_commit_root(trans, root);
Chris Masone02119d2008-09-05 16:13:11 -04001221
Li Zefan82d59022011-04-20 10:33:24 +08001222 btrfs_save_ino_cache(root, trans);
1223
Liu Bof1ebcc72011-11-14 20:48:06 -05001224 /* see comments in should_cow_block() */
Miao Xie27cdeb72014-04-02 19:51:05 +08001225 clear_bit(BTRFS_ROOT_FORCE_COW, &root->state);
Chris Masonc7548af2014-06-10 13:06:56 -07001226 smp_mb__after_atomic();
Liu Bof1ebcc72011-11-14 20:48:06 -05001227
Yan Zheng978d9102009-06-15 20:01:02 -04001228 if (root->commit_root != root->node) {
Josef Bacik9e351cc2014-03-13 15:42:13 -04001229 list_add_tail(&root->dirty_list,
1230 &trans->transaction->switch_commits);
Yan Zheng978d9102009-06-15 20:01:02 -04001231 btrfs_set_root_node(&root->root_item,
1232 root->node);
1233 }
Chris Mason9f3a7422007-08-07 15:52:19 -04001234
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001235 err = btrfs_update_root(trans, fs_info->tree_root,
Chris Mason0f7d52f2007-04-09 10:42:37 -04001236 &root->root_key,
1237 &root->root_item);
Josef Bacika4abeea2011-04-11 17:25:13 -04001238 spin_lock(&fs_info->fs_roots_radix_lock);
Chris Mason54aa1f42007-06-22 14:16:25 -04001239 if (err)
1240 break;
Chris Mason0f7d52f2007-04-09 10:42:37 -04001241 }
1242 }
Josef Bacika4abeea2011-04-11 17:25:13 -04001243 spin_unlock(&fs_info->fs_roots_radix_lock);
Chris Mason54aa1f42007-06-22 14:16:25 -04001244 return err;
Chris Mason0f7d52f2007-04-09 10:42:37 -04001245}
1246
Chris Masond352ac62008-09-29 15:18:18 -04001247/*
Eric Sandeende78b512013-01-31 18:21:12 +00001248 * defrag a given btree.
1249 * Every leaf in the btree is read and defragged.
Chris Masond352ac62008-09-29 15:18:18 -04001250 */
Eric Sandeende78b512013-01-31 18:21:12 +00001251int btrfs_defrag_root(struct btrfs_root *root)
Chris Masone9d0b132007-08-10 14:06:19 -04001252{
1253 struct btrfs_fs_info *info = root->fs_info;
Chris Masone9d0b132007-08-10 14:06:19 -04001254 struct btrfs_trans_handle *trans;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001255 int ret;
Chris Masone9d0b132007-08-10 14:06:19 -04001256
Miao Xie27cdeb72014-04-02 19:51:05 +08001257 if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state))
Chris Masone9d0b132007-08-10 14:06:19 -04001258 return 0;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001259
Chris Mason6b800532007-10-15 16:17:34 -04001260 while (1) {
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001261 trans = btrfs_start_transaction(root, 0);
1262 if (IS_ERR(trans))
1263 return PTR_ERR(trans);
1264
Eric Sandeende78b512013-01-31 18:21:12 +00001265 ret = btrfs_defrag_leaves(trans, root);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001266
Chris Masone9d0b132007-08-10 14:06:19 -04001267 btrfs_end_transaction(trans, root);
Liu Bob53d3f52012-11-14 14:34:34 +00001268 btrfs_btree_balance_dirty(info->tree_root);
Chris Masone9d0b132007-08-10 14:06:19 -04001269 cond_resched();
1270
David Sterba7841cb22011-05-31 18:07:27 +02001271 if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
Chris Masone9d0b132007-08-10 14:06:19 -04001272 break;
David Sterba210549e2013-02-09 23:38:06 +00001273
1274 if (btrfs_defrag_cancelled(root->fs_info)) {
Frank Holtonefe120a2013-12-20 11:37:06 -05001275 pr_debug("BTRFS: defrag_root cancelled\n");
David Sterba210549e2013-02-09 23:38:06 +00001276 ret = -EAGAIN;
1277 break;
1278 }
Chris Masone9d0b132007-08-10 14:06:19 -04001279 }
Miao Xie27cdeb72014-04-02 19:51:05 +08001280 clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001281 return ret;
Chris Masone9d0b132007-08-10 14:06:19 -04001282}
1283
Chris Masond352ac62008-09-29 15:18:18 -04001284/*
1285 * new snapshots need to be created at a very specific time in the
Miao Xieaec80302013-03-04 09:44:29 +00001286 * transaction commit. This does the actual creation.
1287 *
1288 * Note:
1289 * If the error which may affect the commitment of the current transaction
1290 * happens, we should return the error number. If the error which just affect
1291 * the creation of the pending snapshots, just return 0.
Chris Masond352ac62008-09-29 15:18:18 -04001292 */
Chris Mason80b67942008-02-01 16:35:04 -05001293static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
Chris Mason3063d292008-01-08 15:46:30 -05001294 struct btrfs_fs_info *fs_info,
1295 struct btrfs_pending_snapshot *pending)
1296{
1297 struct btrfs_key key;
Chris Mason80b67942008-02-01 16:35:04 -05001298 struct btrfs_root_item *new_root_item;
Chris Mason3063d292008-01-08 15:46:30 -05001299 struct btrfs_root *tree_root = fs_info->tree_root;
1300 struct btrfs_root *root = pending->root;
Sage Weil6bdb72d2010-03-15 17:27:13 +00001301 struct btrfs_root *parent_root;
Liu Bo98c99422011-09-11 10:52:24 -04001302 struct btrfs_block_rsv *rsv;
Sage Weil6bdb72d2010-03-15 17:27:13 +00001303 struct inode *parent_inode;
Miao Xie42874b32012-09-06 04:03:32 -06001304 struct btrfs_path *path;
1305 struct btrfs_dir_item *dir_item;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001306 struct dentry *dentry;
Chris Mason3063d292008-01-08 15:46:30 -05001307 struct extent_buffer *tmp;
Chris Mason925baed2008-06-25 16:01:30 -04001308 struct extent_buffer *old;
Alexander Block8ea05e32012-07-25 17:35:53 +02001309 struct timespec cur_time = CURRENT_TIME;
Miao Xieaec80302013-03-04 09:44:29 +00001310 int ret = 0;
Yan, Zhengd68fc572010-05-16 10:49:58 -04001311 u64 to_reserve = 0;
Sage Weil6bdb72d2010-03-15 17:27:13 +00001312 u64 index = 0;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001313 u64 objectid;
Li Zefanb83cc962010-12-20 16:04:08 +08001314 u64 root_flags;
Alexander Block8ea05e32012-07-25 17:35:53 +02001315 uuid_le new_uuid;
Chris Mason3063d292008-01-08 15:46:30 -05001316
Miao Xie42874b32012-09-06 04:03:32 -06001317 path = btrfs_alloc_path();
1318 if (!path) {
Miao Xieaec80302013-03-04 09:44:29 +00001319 pending->error = -ENOMEM;
1320 return 0;
Miao Xie42874b32012-09-06 04:03:32 -06001321 }
1322
Chris Mason80b67942008-02-01 16:35:04 -05001323 new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
1324 if (!new_root_item) {
Miao Xieaec80302013-03-04 09:44:29 +00001325 pending->error = -ENOMEM;
Miao Xie6fa97002012-09-06 04:00:32 -06001326 goto root_item_alloc_fail;
Chris Mason80b67942008-02-01 16:35:04 -05001327 }
Yan, Zhenga22285a2010-05-16 10:48:46 -04001328
Miao Xieaec80302013-03-04 09:44:29 +00001329 pending->error = btrfs_find_free_objectid(tree_root, &objectid);
1330 if (pending->error)
Miao Xie6fa97002012-09-06 04:00:32 -06001331 goto no_free_objectid;
Chris Mason3063d292008-01-08 15:46:30 -05001332
Qu Wenruod6726332015-04-20 10:09:06 +08001333 /*
1334 * Make qgroup to skip current new snapshot's qgroupid, as it is
1335 * accounted by later btrfs_qgroup_inherit().
1336 */
1337 btrfs_set_skip_qgroup(trans, objectid);
1338
Zhaolei147d2562015-08-06 20:58:11 +08001339 btrfs_reloc_pre_snapshot(pending, &to_reserve);
Yan, Zhengd68fc572010-05-16 10:49:58 -04001340
1341 if (to_reserve > 0) {
Miao Xieaec80302013-03-04 09:44:29 +00001342 pending->error = btrfs_block_rsv_add(root,
1343 &pending->block_rsv,
1344 to_reserve,
1345 BTRFS_RESERVE_NO_FLUSH);
1346 if (pending->error)
Qu Wenruod6726332015-04-20 10:09:06 +08001347 goto clear_skip_qgroup;
Yan, Zhengd68fc572010-05-16 10:49:58 -04001348 }
1349
Chris Mason3063d292008-01-08 15:46:30 -05001350 key.objectid = objectid;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001351 key.offset = (u64)-1;
1352 key.type = BTRFS_ROOT_ITEM_KEY;
Chris Mason3063d292008-01-08 15:46:30 -05001353
Miao Xie6fa97002012-09-06 04:00:32 -06001354 rsv = trans->block_rsv;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001355 trans->block_rsv = &pending->block_rsv;
Liu Bo2382c5c2013-02-22 04:33:36 +00001356 trans->bytes_reserved = trans->block_rsv->reserved;
Sage Weil6bdb72d2010-03-15 17:27:13 +00001357
Yan, Zhenga22285a2010-05-16 10:48:46 -04001358 dentry = pending->dentry;
Miao Xiee9662f72013-02-28 10:01:15 +00001359 parent_inode = pending->dir;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001360 parent_root = BTRFS_I(parent_inode)->root;
Chris Mason75857172011-06-13 20:00:16 -04001361 record_root_in_trans(trans, parent_root);
Yan, Zhenga22285a2010-05-16 10:48:46 -04001362
Sage Weil6bdb72d2010-03-15 17:27:13 +00001363 /*
1364 * insert the directory item
1365 */
Sage Weil6bdb72d2010-03-15 17:27:13 +00001366 ret = btrfs_set_inode_index(parent_inode, &index);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001367 BUG_ON(ret); /* -ENOMEM */
Miao Xie42874b32012-09-06 04:03:32 -06001368
1369 /* check if there is a file/dir which has the same name. */
1370 dir_item = btrfs_lookup_dir_item(NULL, parent_root, path,
1371 btrfs_ino(parent_inode),
1372 dentry->d_name.name,
1373 dentry->d_name.len, 0);
1374 if (dir_item != NULL && !IS_ERR(dir_item)) {
Chris Masonfe66a052012-02-20 08:40:56 -05001375 pending->error = -EEXIST;
Miao Xieaec80302013-03-04 09:44:29 +00001376 goto dir_item_existed;
Miao Xie42874b32012-09-06 04:03:32 -06001377 } else if (IS_ERR(dir_item)) {
1378 ret = PTR_ERR(dir_item);
Miao Xie8732d442012-09-17 23:52:38 -06001379 btrfs_abort_transaction(trans, root, ret);
1380 goto fail;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001381 }
Miao Xie42874b32012-09-06 04:03:32 -06001382 btrfs_release_path(path);
Sage Weil6bdb72d2010-03-15 17:27:13 +00001383
Chris Masone9993762011-06-17 16:14:09 -04001384 /*
1385 * pull in the delayed directory update
1386 * and the delayed inode item
1387 * otherwise we corrupt the FS during
1388 * snapshot
1389 */
1390 ret = btrfs_run_delayed_items(trans, root);
Miao Xie8732d442012-09-17 23:52:38 -06001391 if (ret) { /* Transaction aborted */
1392 btrfs_abort_transaction(trans, root, ret);
1393 goto fail;
1394 }
Chris Masone9993762011-06-17 16:14:09 -04001395
Chris Mason75857172011-06-13 20:00:16 -04001396 record_root_in_trans(trans, root);
Sage Weil6bdb72d2010-03-15 17:27:13 +00001397 btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
1398 memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
Li Zefan08fe4db2011-03-28 02:01:25 +00001399 btrfs_check_and_init_root_item(new_root_item);
Sage Weil6bdb72d2010-03-15 17:27:13 +00001400
Li Zefanb83cc962010-12-20 16:04:08 +08001401 root_flags = btrfs_root_flags(new_root_item);
1402 if (pending->readonly)
1403 root_flags |= BTRFS_ROOT_SUBVOL_RDONLY;
1404 else
1405 root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY;
1406 btrfs_set_root_flags(new_root_item, root_flags);
1407
Alexander Block8ea05e32012-07-25 17:35:53 +02001408 btrfs_set_root_generation_v2(new_root_item,
1409 trans->transid);
1410 uuid_le_gen(&new_uuid);
1411 memcpy(new_root_item->uuid, new_uuid.b, BTRFS_UUID_SIZE);
1412 memcpy(new_root_item->parent_uuid, root->root_item.uuid,
1413 BTRFS_UUID_SIZE);
Stefan Behrens70023da2013-04-17 09:11:47 +00001414 if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) {
1415 memset(new_root_item->received_uuid, 0,
1416 sizeof(new_root_item->received_uuid));
1417 memset(&new_root_item->stime, 0, sizeof(new_root_item->stime));
1418 memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime));
1419 btrfs_set_root_stransid(new_root_item, 0);
1420 btrfs_set_root_rtransid(new_root_item, 0);
1421 }
Qu Wenruo3cae2102013-07-16 11:19:18 +08001422 btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec);
1423 btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec);
Alexander Block8ea05e32012-07-25 17:35:53 +02001424 btrfs_set_root_otransid(new_root_item, trans->transid);
Alexander Block8ea05e32012-07-25 17:35:53 +02001425
Chris Mason925baed2008-06-25 16:01:30 -04001426 old = btrfs_lock_root_node(root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001427 ret = btrfs_cow_block(trans, root, old, NULL, 0, &old);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001428 if (ret) {
1429 btrfs_tree_unlock(old);
1430 free_extent_buffer(old);
Miao Xie8732d442012-09-17 23:52:38 -06001431 btrfs_abort_transaction(trans, root, ret);
1432 goto fail;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001433 }
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001434
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001435 btrfs_set_lock_blocking(old);
Chris Mason3063d292008-01-08 15:46:30 -05001436
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001437 ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001438 /* clean up in any case */
Chris Mason925baed2008-06-25 16:01:30 -04001439 btrfs_tree_unlock(old);
1440 free_extent_buffer(old);
Miao Xie8732d442012-09-17 23:52:38 -06001441 if (ret) {
1442 btrfs_abort_transaction(trans, root, ret);
1443 goto fail;
1444 }
Liu Bof1ebcc72011-11-14 20:48:06 -05001445 /* see comments in should_cow_block() */
Miao Xie27cdeb72014-04-02 19:51:05 +08001446 set_bit(BTRFS_ROOT_FORCE_COW, &root->state);
Liu Bof1ebcc72011-11-14 20:48:06 -05001447 smp_wmb();
1448
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001449 btrfs_set_root_node(new_root_item, tmp);
Yan, Zhenga22285a2010-05-16 10:48:46 -04001450 /* record when the snapshot was created in key.offset */
1451 key.offset = trans->transid;
1452 ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
Chris Mason925baed2008-06-25 16:01:30 -04001453 btrfs_tree_unlock(tmp);
Chris Mason3063d292008-01-08 15:46:30 -05001454 free_extent_buffer(tmp);
Miao Xie8732d442012-09-17 23:52:38 -06001455 if (ret) {
1456 btrfs_abort_transaction(trans, root, ret);
1457 goto fail;
1458 }
Chris Mason0660b5a2008-11-17 20:37:39 -05001459
Yan, Zhenga22285a2010-05-16 10:48:46 -04001460 /*
1461 * insert root back/forward references
1462 */
1463 ret = btrfs_add_root_ref(trans, tree_root, objectid,
1464 parent_root->root_key.objectid,
Li Zefan33345d012011-04-20 10:31:50 +08001465 btrfs_ino(parent_inode), index,
Yan, Zhenga22285a2010-05-16 10:48:46 -04001466 dentry->d_name.name, dentry->d_name.len);
Miao Xie8732d442012-09-17 23:52:38 -06001467 if (ret) {
1468 btrfs_abort_transaction(trans, root, ret);
1469 goto fail;
1470 }
Yan, Zhenga22285a2010-05-16 10:48:46 -04001471
1472 key.offset = (u64)-1;
1473 pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001474 if (IS_ERR(pending->snap)) {
1475 ret = PTR_ERR(pending->snap);
Miao Xie8732d442012-09-17 23:52:38 -06001476 btrfs_abort_transaction(trans, root, ret);
1477 goto fail;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001478 }
Yan, Zhengd68fc572010-05-16 10:49:58 -04001479
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001480 ret = btrfs_reloc_post_snapshot(trans, pending);
Miao Xie8732d442012-09-17 23:52:38 -06001481 if (ret) {
1482 btrfs_abort_transaction(trans, root, ret);
1483 goto fail;
1484 }
Miao Xie361048f2012-09-06 04:00:57 -06001485
1486 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Miao Xie8732d442012-09-17 23:52:38 -06001487 if (ret) {
1488 btrfs_abort_transaction(trans, root, ret);
1489 goto fail;
1490 }
Miao Xie42874b32012-09-06 04:03:32 -06001491
1492 ret = btrfs_insert_dir_item(trans, parent_root,
1493 dentry->d_name.name, dentry->d_name.len,
1494 parent_inode, &key,
1495 BTRFS_FT_DIR, index);
1496 /* We have check then name at the beginning, so it is impossible. */
Chris Mason9c520572012-12-17 14:26:57 -05001497 BUG_ON(ret == -EEXIST || ret == -EOVERFLOW);
Miao Xie8732d442012-09-17 23:52:38 -06001498 if (ret) {
1499 btrfs_abort_transaction(trans, root, ret);
1500 goto fail;
1501 }
Miao Xie42874b32012-09-06 04:03:32 -06001502
1503 btrfs_i_size_write(parent_inode, parent_inode->i_size +
1504 dentry->d_name.len * 2);
1505 parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
Josef Bacikbe6aef62012-10-22 15:43:12 -04001506 ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode);
Stefan Behrensdd5f9612013-08-15 17:11:20 +02001507 if (ret) {
Miao Xie8732d442012-09-17 23:52:38 -06001508 btrfs_abort_transaction(trans, root, ret);
Stefan Behrensdd5f9612013-08-15 17:11:20 +02001509 goto fail;
1510 }
1511 ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root, new_uuid.b,
1512 BTRFS_UUID_KEY_SUBVOL, objectid);
1513 if (ret) {
1514 btrfs_abort_transaction(trans, root, ret);
1515 goto fail;
1516 }
1517 if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) {
1518 ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root,
1519 new_root_item->received_uuid,
1520 BTRFS_UUID_KEY_RECEIVED_SUBVOL,
1521 objectid);
1522 if (ret && ret != -EEXIST) {
1523 btrfs_abort_transaction(trans, root, ret);
1524 goto fail;
1525 }
1526 }
Qu Wenruod6726332015-04-20 10:09:06 +08001527
1528 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1529 if (ret) {
1530 btrfs_abort_transaction(trans, root, ret);
1531 goto fail;
1532 }
1533
1534 /*
1535 * account qgroup counters before qgroup_inherit()
1536 */
1537 ret = btrfs_qgroup_prepare_account_extents(trans, fs_info);
1538 if (ret)
1539 goto fail;
1540 ret = btrfs_qgroup_account_extents(trans, fs_info);
1541 if (ret)
1542 goto fail;
1543 ret = btrfs_qgroup_inherit(trans, fs_info,
1544 root->root_key.objectid,
1545 objectid, pending->inherit);
1546 if (ret) {
1547 btrfs_abort_transaction(trans, root, ret);
1548 goto fail;
1549 }
1550
Chris Mason3063d292008-01-08 15:46:30 -05001551fail:
Miao Xieaec80302013-03-04 09:44:29 +00001552 pending->error = ret;
1553dir_item_existed:
Liu Bo98c99422011-09-11 10:52:24 -04001554 trans->block_rsv = rsv;
Liu Bo2382c5c2013-02-22 04:33:36 +00001555 trans->bytes_reserved = 0;
Qu Wenruod6726332015-04-20 10:09:06 +08001556clear_skip_qgroup:
1557 btrfs_clear_skip_qgroup(trans);
Miao Xie6fa97002012-09-06 04:00:32 -06001558no_free_objectid:
1559 kfree(new_root_item);
1560root_item_alloc_fail:
Miao Xie42874b32012-09-06 04:03:32 -06001561 btrfs_free_path(path);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001562 return ret;
Chris Mason3063d292008-01-08 15:46:30 -05001563}
1564
Chris Masond352ac62008-09-29 15:18:18 -04001565/*
1566 * create all the snapshots we've scheduled for creation
1567 */
Chris Mason80b67942008-02-01 16:35:04 -05001568static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
1569 struct btrfs_fs_info *fs_info)
Chris Mason3063d292008-01-08 15:46:30 -05001570{
Miao Xieaec80302013-03-04 09:44:29 +00001571 struct btrfs_pending_snapshot *pending, *next;
Chris Mason3063d292008-01-08 15:46:30 -05001572 struct list_head *head = &trans->transaction->pending_snapshots;
Miao Xieaec80302013-03-04 09:44:29 +00001573 int ret = 0;
Chris Mason3de45862008-11-17 21:02:50 -05001574
Miao Xieaec80302013-03-04 09:44:29 +00001575 list_for_each_entry_safe(pending, next, head, list) {
1576 list_del(&pending->list);
1577 ret = create_pending_snapshot(trans, fs_info, pending);
1578 if (ret)
1579 break;
1580 }
1581 return ret;
Chris Mason3de45862008-11-17 21:02:50 -05001582}
1583
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001584static void update_super_roots(struct btrfs_root *root)
1585{
1586 struct btrfs_root_item *root_item;
1587 struct btrfs_super_block *super;
1588
David Sterba6c417612011-04-13 15:41:04 +02001589 super = root->fs_info->super_copy;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001590
1591 root_item = &root->fs_info->chunk_root->root_item;
1592 super->chunk_root = root_item->bytenr;
1593 super->chunk_root_generation = root_item->generation;
1594 super->chunk_root_level = root_item->level;
1595
1596 root_item = &root->fs_info->tree_root->root_item;
1597 super->root = root_item->bytenr;
1598 super->generation = root_item->generation;
1599 super->root_level = root_item->level;
Josef Bacik73bc1872011-10-03 14:07:49 -04001600 if (btrfs_test_opt(root, SPACE_CACHE))
Josef Bacik0af3d002010-06-21 14:48:16 -04001601 super->cache_generation = root_item->generation;
Stefan Behrens70f80172013-08-15 17:11:23 +02001602 if (root->fs_info->update_uuid_tree_gen)
1603 super->uuid_tree_generation = root_item->generation;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001604}
1605
Chris Masonf36f3042009-07-30 10:04:48 -04001606int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
1607{
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001608 struct btrfs_transaction *trans;
Chris Masonf36f3042009-07-30 10:04:48 -04001609 int ret = 0;
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001610
Josef Bacika4abeea2011-04-11 17:25:13 -04001611 spin_lock(&info->trans_lock);
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001612 trans = info->running_transaction;
1613 if (trans)
1614 ret = (trans->state >= TRANS_STATE_COMMIT_START);
Josef Bacika4abeea2011-04-11 17:25:13 -04001615 spin_unlock(&info->trans_lock);
Chris Masonf36f3042009-07-30 10:04:48 -04001616 return ret;
1617}
1618
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001619int btrfs_transaction_blocked(struct btrfs_fs_info *info)
1620{
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001621 struct btrfs_transaction *trans;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001622 int ret = 0;
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001623
Josef Bacika4abeea2011-04-11 17:25:13 -04001624 spin_lock(&info->trans_lock);
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001625 trans = info->running_transaction;
1626 if (trans)
1627 ret = is_transaction_blocked(trans);
Josef Bacika4abeea2011-04-11 17:25:13 -04001628 spin_unlock(&info->trans_lock);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001629 return ret;
1630}
1631
Sage Weilbb9c12c2010-10-29 15:37:34 -04001632/*
1633 * wait for the current transaction commit to start and block subsequent
1634 * transaction joins
1635 */
1636static void wait_current_trans_commit_start(struct btrfs_root *root,
1637 struct btrfs_transaction *trans)
1638{
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001639 wait_event(root->fs_info->transaction_blocked_wait,
Josef Bacik501407a2013-06-10 16:47:23 -04001640 trans->state >= TRANS_STATE_COMMIT_START ||
1641 trans->aborted);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001642}
1643
1644/*
1645 * wait for the current transaction to start and then become unblocked.
1646 * caller holds ref.
1647 */
1648static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root,
1649 struct btrfs_transaction *trans)
1650{
Li Zefan72d63ed2011-07-14 03:17:00 +00001651 wait_event(root->fs_info->transaction_wait,
Josef Bacik501407a2013-06-10 16:47:23 -04001652 trans->state >= TRANS_STATE_UNBLOCKED ||
1653 trans->aborted);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001654}
1655
1656/*
1657 * commit transactions asynchronously. once btrfs_commit_transaction_async
1658 * returns, any subsequent transaction will not be allowed to join.
1659 */
1660struct btrfs_async_commit {
1661 struct btrfs_trans_handle *newtrans;
1662 struct btrfs_root *root;
Miao Xie7892b5a2012-11-15 08:14:47 +00001663 struct work_struct work;
Sage Weilbb9c12c2010-10-29 15:37:34 -04001664};
1665
1666static void do_async_commit(struct work_struct *work)
1667{
1668 struct btrfs_async_commit *ac =
Miao Xie7892b5a2012-11-15 08:14:47 +00001669 container_of(work, struct btrfs_async_commit, work);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001670
Sage Weil6fc4e35482012-08-30 16:26:15 -06001671 /*
1672 * We've got freeze protection passed with the transaction.
1673 * Tell lockdep about it.
1674 */
Liu Bob1a06a42013-11-06 16:57:55 +08001675 if (ac->newtrans->type & __TRANS_FREEZABLE)
Oleg Nesterovbee91822015-07-19 23:48:20 +02001676 __sb_writers_acquired(ac->root->fs_info->sb, SB_FREEZE_FS);
Sage Weil6fc4e35482012-08-30 16:26:15 -06001677
Sage Weile209db72012-08-30 16:26:16 -06001678 current->journal_info = ac->newtrans;
1679
Sage Weilbb9c12c2010-10-29 15:37:34 -04001680 btrfs_commit_transaction(ac->newtrans, ac->root);
1681 kfree(ac);
1682}
1683
1684int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
1685 struct btrfs_root *root,
1686 int wait_for_unblock)
1687{
1688 struct btrfs_async_commit *ac;
1689 struct btrfs_transaction *cur_trans;
1690
1691 ac = kmalloc(sizeof(*ac), GFP_NOFS);
Tsutomu Itohdb5b4932011-03-23 08:14:16 +00001692 if (!ac)
1693 return -ENOMEM;
Sage Weilbb9c12c2010-10-29 15:37:34 -04001694
Miao Xie7892b5a2012-11-15 08:14:47 +00001695 INIT_WORK(&ac->work, do_async_commit);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001696 ac->root = root;
Josef Bacik7a7eaa42011-04-13 12:54:33 -04001697 ac->newtrans = btrfs_join_transaction(root);
Tsutomu Itoh3612b492011-01-25 02:51:38 +00001698 if (IS_ERR(ac->newtrans)) {
1699 int err = PTR_ERR(ac->newtrans);
1700 kfree(ac);
1701 return err;
1702 }
Sage Weilbb9c12c2010-10-29 15:37:34 -04001703
1704 /* take transaction reference */
Sage Weilbb9c12c2010-10-29 15:37:34 -04001705 cur_trans = trans->transaction;
Josef Bacik13c5a932011-04-11 15:45:29 -04001706 atomic_inc(&cur_trans->use_count);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001707
1708 btrfs_end_transaction(trans, root);
Sage Weil6fc4e35482012-08-30 16:26:15 -06001709
1710 /*
1711 * Tell lockdep we've released the freeze rwsem, since the
1712 * async commit thread will be the one to unlock it.
1713 */
Liu Bob1a06a42013-11-06 16:57:55 +08001714 if (ac->newtrans->type & __TRANS_FREEZABLE)
Oleg Nesterovbee91822015-07-19 23:48:20 +02001715 __sb_writers_release(root->fs_info->sb, SB_FREEZE_FS);
Sage Weil6fc4e35482012-08-30 16:26:15 -06001716
Miao Xie7892b5a2012-11-15 08:14:47 +00001717 schedule_work(&ac->work);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001718
1719 /* wait for transaction to start and unblock */
Sage Weilbb9c12c2010-10-29 15:37:34 -04001720 if (wait_for_unblock)
1721 wait_current_trans_commit_start_and_unblock(root, cur_trans);
1722 else
1723 wait_current_trans_commit_start(root, cur_trans);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001724
Sage Weil38e88052011-06-10 18:43:13 +00001725 if (current->journal_info == trans)
1726 current->journal_info = NULL;
1727
Josef Bacik724e2312013-09-30 11:36:38 -04001728 btrfs_put_transaction(cur_trans);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001729 return 0;
1730}
1731
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001732
1733static void cleanup_transaction(struct btrfs_trans_handle *trans,
Josef Bacik7b8b92a2012-05-31 15:52:43 -04001734 struct btrfs_root *root, int err)
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001735{
1736 struct btrfs_transaction *cur_trans = trans->transaction;
Liu Bof094ac32013-02-27 13:28:25 +00001737 DEFINE_WAIT(wait);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001738
1739 WARN_ON(trans->use_count > 1);
1740
Josef Bacik7b8b92a2012-05-31 15:52:43 -04001741 btrfs_abort_transaction(trans, root, err);
1742
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001743 spin_lock(&root->fs_info->trans_lock);
Liu Bo66b61352013-03-04 16:25:41 +00001744
Miao Xie25d8c282013-05-15 07:48:26 +00001745 /*
1746 * If the transaction is removed from the list, it means this
1747 * transaction has been committed successfully, so it is impossible
1748 * to call the cleanup function.
1749 */
1750 BUG_ON(list_empty(&cur_trans->list));
Liu Bo66b61352013-03-04 16:25:41 +00001751
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001752 list_del_init(&cur_trans->list);
Josef Bacikd7096fc2012-05-31 15:49:57 -04001753 if (cur_trans == root->fs_info->running_transaction) {
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001754 cur_trans->state = TRANS_STATE_COMMIT_DOING;
Liu Bof094ac32013-02-27 13:28:25 +00001755 spin_unlock(&root->fs_info->trans_lock);
1756 wait_event(cur_trans->writer_wait,
1757 atomic_read(&cur_trans->num_writers) == 1);
1758
1759 spin_lock(&root->fs_info->trans_lock);
Josef Bacikd7096fc2012-05-31 15:49:57 -04001760 }
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001761 spin_unlock(&root->fs_info->trans_lock);
1762
1763 btrfs_cleanup_one_transaction(trans->transaction, root);
1764
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001765 spin_lock(&root->fs_info->trans_lock);
1766 if (cur_trans == root->fs_info->running_transaction)
1767 root->fs_info->running_transaction = NULL;
1768 spin_unlock(&root->fs_info->trans_lock);
1769
Josef Bacike0228282013-09-20 22:26:29 -04001770 if (trans->type & __TRANS_FREEZABLE)
1771 sb_end_intwrite(root->fs_info->sb);
Josef Bacik724e2312013-09-30 11:36:38 -04001772 btrfs_put_transaction(cur_trans);
1773 btrfs_put_transaction(cur_trans);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001774
1775 trace_btrfs_transaction_commit(root);
1776
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001777 if (current->journal_info == trans)
1778 current->journal_info = NULL;
Wang Shilongc0af8f02014-02-19 19:24:18 +08001779 btrfs_scrub_cancel(root->fs_info);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001780
1781 kmem_cache_free(btrfs_trans_handle_cachep, trans);
1782}
1783
Miao Xie82436612013-05-15 07:48:28 +00001784static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info)
1785{
1786 if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT))
Miao Xie6c255e62014-03-06 13:55:01 +08001787 return btrfs_start_delalloc_roots(fs_info, 1, -1);
Miao Xie82436612013-05-15 07:48:28 +00001788 return 0;
1789}
1790
1791static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info)
1792{
1793 if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT))
Miao Xieb0244192013-11-04 23:13:25 +08001794 btrfs_wait_ordered_roots(fs_info, -1);
Miao Xie82436612013-05-15 07:48:28 +00001795}
1796
Josef Bacik50d9aa92014-11-21 14:52:38 -05001797static inline void
1798btrfs_wait_pending_ordered(struct btrfs_transaction *cur_trans,
1799 struct btrfs_fs_info *fs_info)
1800{
1801 struct btrfs_ordered_extent *ordered;
1802
1803 spin_lock(&fs_info->trans_lock);
1804 while (!list_empty(&cur_trans->pending_ordered)) {
1805 ordered = list_first_entry(&cur_trans->pending_ordered,
1806 struct btrfs_ordered_extent,
1807 trans_list);
1808 list_del_init(&ordered->trans_list);
1809 spin_unlock(&fs_info->trans_lock);
1810
1811 wait_event(ordered->wait, test_bit(BTRFS_ORDERED_COMPLETE,
1812 &ordered->flags));
1813 btrfs_put_ordered_extent(ordered);
1814 spin_lock(&fs_info->trans_lock);
1815 }
1816 spin_unlock(&fs_info->trans_lock);
1817}
1818
Chris Mason79154b12007-03-22 15:59:16 -04001819int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
1820 struct btrfs_root *root)
1821{
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001822 struct btrfs_transaction *cur_trans = trans->transaction;
Chris Mason8fd17792007-04-19 21:01:03 -04001823 struct btrfs_transaction *prev_trans = NULL;
Filipe Manana656f30d2014-09-26 12:25:56 +01001824 struct btrfs_inode *btree_ino = BTRFS_I(root->fs_info->btree_inode);
Miao Xie25287e02012-10-25 09:31:03 +00001825 int ret;
Chris Mason79154b12007-03-22 15:59:16 -04001826
Miao Xie8d25a082013-01-15 06:27:25 +00001827 /* Stop the commit early if ->aborted is set */
1828 if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
Miao Xie25287e02012-10-25 09:31:03 +00001829 ret = cur_trans->aborted;
Josef Bacike4a2bca2013-02-06 16:55:41 -05001830 btrfs_end_transaction(trans, root);
1831 return ret;
Miao Xie25287e02012-10-25 09:31:03 +00001832 }
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001833
Chris Mason56bec292009-03-13 10:10:06 -04001834 /* make a pass through all the delayed refs we have so far
1835 * any runnings procs may add more while we are here
1836 */
1837 ret = btrfs_run_delayed_refs(trans, root, 0);
Josef Bacike4a2bca2013-02-06 16:55:41 -05001838 if (ret) {
1839 btrfs_end_transaction(trans, root);
1840 return ret;
1841 }
Chris Mason56bec292009-03-13 10:10:06 -04001842
Josef Bacik0e721102012-06-26 16:13:18 -04001843 btrfs_trans_release_metadata(trans, root);
1844 trans->block_rsv = NULL;
Miao Xie272d26d2013-02-20 14:16:39 +00001845 if (trans->qgroup_reserved) {
1846 btrfs_qgroup_free(root, trans->qgroup_reserved);
1847 trans->qgroup_reserved = 0;
1848 }
Josef Bacik0e721102012-06-26 16:13:18 -04001849
Chris Masonb7ec40d2009-03-12 20:12:45 -04001850 cur_trans = trans->transaction;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001851
Chris Mason56bec292009-03-13 10:10:06 -04001852 /*
1853 * set the flushing flag so procs in this transaction have to
1854 * start sending their work down.
1855 */
Chris Masonb7ec40d2009-03-12 20:12:45 -04001856 cur_trans->delayed_refs.flushing = 1;
Josef Bacik1be41b72013-06-12 13:56:06 -04001857 smp_wmb();
Chris Mason56bec292009-03-13 10:10:06 -04001858
Josef Bacikea658ba2012-09-11 16:57:25 -04001859 if (!list_empty(&trans->new_bgs))
1860 btrfs_create_pending_block_groups(trans, root);
1861
Chris Masonc3e69d52009-03-13 10:17:05 -04001862 ret = btrfs_run_delayed_refs(trans, root, 0);
Josef Bacike4a2bca2013-02-06 16:55:41 -05001863 if (ret) {
1864 btrfs_end_transaction(trans, root);
1865 return ret;
1866 }
Chris Mason56bec292009-03-13 10:10:06 -04001867
Chris Mason1bbc6212015-04-06 12:46:08 -07001868 if (!cur_trans->dirty_bg_run) {
1869 int run_it = 0;
1870
1871 /* this mutex is also taken before trying to set
1872 * block groups readonly. We need to make sure
1873 * that nobody has set a block group readonly
1874 * after a extents from that block group have been
1875 * allocated for cache files. btrfs_set_block_group_ro
1876 * will wait for the transaction to commit if it
1877 * finds dirty_bg_run = 1
1878 *
1879 * The dirty_bg_run flag is also used to make sure only
1880 * one process starts all the block group IO. It wouldn't
1881 * hurt to have more than one go through, but there's no
1882 * real advantage to it either.
1883 */
1884 mutex_lock(&root->fs_info->ro_block_group_mutex);
1885 if (!cur_trans->dirty_bg_run) {
1886 run_it = 1;
1887 cur_trans->dirty_bg_run = 1;
1888 }
1889 mutex_unlock(&root->fs_info->ro_block_group_mutex);
1890
1891 if (run_it)
1892 ret = btrfs_start_dirty_block_groups(trans, root);
1893 }
1894 if (ret) {
1895 btrfs_end_transaction(trans, root);
1896 return ret;
1897 }
1898
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001899 spin_lock(&root->fs_info->trans_lock);
Filipe Mananad3efe082015-07-03 20:30:34 +01001900 list_splice_init(&trans->ordered, &cur_trans->pending_ordered);
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001901 if (cur_trans->state >= TRANS_STATE_COMMIT_START) {
1902 spin_unlock(&root->fs_info->trans_lock);
Josef Bacik13c5a932011-04-11 15:45:29 -04001903 atomic_inc(&cur_trans->use_count);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001904 ret = btrfs_end_transaction(trans, root);
Chris Masonccd467d2007-06-28 15:57:36 -04001905
Li Zefanb9c83002011-07-14 03:17:14 +00001906 wait_for_commit(root, cur_trans);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001907
Liu Bob4924a02015-03-06 20:23:44 +08001908 if (unlikely(cur_trans->aborted))
1909 ret = cur_trans->aborted;
1910
Josef Bacik724e2312013-09-30 11:36:38 -04001911 btrfs_put_transaction(cur_trans);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001912
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001913 return ret;
Chris Mason79154b12007-03-22 15:59:16 -04001914 }
Chris Mason4313b392008-01-03 09:08:48 -05001915
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001916 cur_trans->state = TRANS_STATE_COMMIT_START;
Sage Weilbb9c12c2010-10-29 15:37:34 -04001917 wake_up(&root->fs_info->transaction_blocked_wait);
1918
Chris Masonccd467d2007-06-28 15:57:36 -04001919 if (cur_trans->list.prev != &root->fs_info->trans_list) {
1920 prev_trans = list_entry(cur_trans->list.prev,
1921 struct btrfs_transaction, list);
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001922 if (prev_trans->state != TRANS_STATE_COMPLETED) {
Josef Bacik13c5a932011-04-11 15:45:29 -04001923 atomic_inc(&prev_trans->use_count);
Josef Bacika4abeea2011-04-11 17:25:13 -04001924 spin_unlock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001925
1926 wait_for_commit(root, prev_trans);
Filipe Manana1f9b8c82015-08-12 11:54:35 +01001927 ret = prev_trans->aborted;
Chris Masonccd467d2007-06-28 15:57:36 -04001928
Josef Bacik724e2312013-09-30 11:36:38 -04001929 btrfs_put_transaction(prev_trans);
Filipe Manana1f9b8c82015-08-12 11:54:35 +01001930 if (ret)
1931 goto cleanup_transaction;
Josef Bacika4abeea2011-04-11 17:25:13 -04001932 } else {
1933 spin_unlock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001934 }
Josef Bacika4abeea2011-04-11 17:25:13 -04001935 } else {
1936 spin_unlock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001937 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001938
Miao Xie0860adf2013-05-15 07:48:27 +00001939 extwriter_counter_dec(cur_trans, trans->type);
1940
Miao Xie82436612013-05-15 07:48:28 +00001941 ret = btrfs_start_delalloc_flush(root->fs_info);
1942 if (ret)
1943 goto cleanup_transaction;
1944
Chris Mason8d875f92014-08-12 10:47:42 -07001945 ret = btrfs_run_delayed_items(trans, root);
Miao Xie581227d2013-05-15 07:48:30 +00001946 if (ret)
1947 goto cleanup_transaction;
Chris Mason89573b92009-03-12 20:12:45 -04001948
Miao Xie581227d2013-05-15 07:48:30 +00001949 wait_event(cur_trans->writer_wait,
1950 extwriter_counter_read(cur_trans) == 0);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001951
Miao Xie581227d2013-05-15 07:48:30 +00001952 /* some pending stuffs might be added after the previous flush. */
Chris Mason8d875f92014-08-12 10:47:42 -07001953 ret = btrfs_run_delayed_items(trans, root);
Miao Xieca469632012-11-01 07:33:14 +00001954 if (ret)
1955 goto cleanup_transaction;
1956
Miao Xie82436612013-05-15 07:48:28 +00001957 btrfs_wait_delalloc_flush(root->fs_info);
Wang Shilongcb7ab022013-12-04 21:16:53 +08001958
Josef Bacik50d9aa92014-11-21 14:52:38 -05001959 btrfs_wait_pending_ordered(cur_trans, root->fs_info);
1960
Wang Shilongcb7ab022013-12-04 21:16:53 +08001961 btrfs_scrub_pause(root);
Chris Mason75857172011-06-13 20:00:16 -04001962 /*
Josef Baciked0ca142011-06-14 16:22:15 -04001963 * Ok now we need to make sure to block out any other joins while we
1964 * commit the transaction. We could have started a join before setting
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001965 * COMMIT_DOING so make sure to wait for num_writers to == 1 again.
Josef Baciked0ca142011-06-14 16:22:15 -04001966 */
1967 spin_lock(&root->fs_info->trans_lock);
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001968 cur_trans->state = TRANS_STATE_COMMIT_DOING;
Josef Baciked0ca142011-06-14 16:22:15 -04001969 spin_unlock(&root->fs_info->trans_lock);
1970 wait_event(cur_trans->writer_wait,
1971 atomic_read(&cur_trans->num_writers) == 1);
1972
Miao Xie2cba30f2013-01-15 06:29:12 +00001973 /* ->aborted might be set after the previous check, so check it */
1974 if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
1975 ret = cur_trans->aborted;
Wang Shilong6cf7f772014-02-19 19:24:16 +08001976 goto scrub_continue;
Miao Xie2cba30f2013-01-15 06:29:12 +00001977 }
Chris Masone038dca2011-06-17 14:16:13 -04001978 /*
Chris Mason75857172011-06-13 20:00:16 -04001979 * the reloc mutex makes sure that we stop
1980 * the balancing code from coming in and moving
1981 * extents around in the middle of the commit
1982 */
1983 mutex_lock(&root->fs_info->reloc_mutex);
1984
Miao Xie42874b32012-09-06 04:03:32 -06001985 /*
1986 * We needn't worry about the delayed items because we will
1987 * deal with them in create_pending_snapshot(), which is the
1988 * core function of the snapshot creation.
1989 */
1990 ret = create_pending_snapshots(trans, root->fs_info);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001991 if (ret) {
1992 mutex_unlock(&root->fs_info->reloc_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08001993 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001994 }
Chris Mason3063d292008-01-08 15:46:30 -05001995
Miao Xie42874b32012-09-06 04:03:32 -06001996 /*
1997 * We insert the dir indexes of the snapshots and update the inode
1998 * of the snapshots' parents after the snapshot creation, so there
1999 * are some delayed items which are not dealt with. Now deal with
2000 * them.
2001 *
2002 * We needn't worry that this operation will corrupt the snapshots,
2003 * because all the tree which are snapshoted will be forced to COW
2004 * the nodes and leaves.
2005 */
2006 ret = btrfs_run_delayed_items(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002007 if (ret) {
2008 mutex_unlock(&root->fs_info->reloc_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08002009 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002010 }
Miao Xie16cdcec2011-04-22 18:12:22 +08002011
Chris Mason56bec292009-03-13 10:10:06 -04002012 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002013 if (ret) {
2014 mutex_unlock(&root->fs_info->reloc_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08002015 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002016 }
Chris Mason56bec292009-03-13 10:10:06 -04002017
Qu Wenruo0ed47922015-04-16 16:55:08 +08002018 /* Reocrd old roots for later qgroup accounting */
2019 ret = btrfs_qgroup_prepare_account_extents(trans, root->fs_info);
2020 if (ret) {
2021 mutex_unlock(&root->fs_info->reloc_mutex);
2022 goto scrub_continue;
2023 }
2024
Chris Masone9993762011-06-17 16:14:09 -04002025 /*
2026 * make sure none of the code above managed to slip in a
2027 * delayed item
2028 */
2029 btrfs_assert_delayed_root_empty(root);
2030
Chris Mason2c90e5d2007-04-02 10:50:19 -04002031 WARN_ON(cur_trans != trans->transaction);
Chris Masondc17ff82008-01-08 15:46:30 -05002032
Chris Masone02119d2008-09-05 16:13:11 -04002033 /* btrfs_commit_tree_roots is responsible for getting the
2034 * various roots consistent with each other. Every pointer
2035 * in the tree of tree roots has to point to the most up to date
2036 * root for every subvolume and other tree. So, we have to keep
2037 * the tree logging code from jumping in and changing any
2038 * of the trees.
2039 *
2040 * At this point in the commit, there can't be any tree-log
2041 * writers, but a little lower down we drop the trans mutex
2042 * and let new people in. By holding the tree_log_mutex
2043 * from now until after the super is written, we avoid races
2044 * with the tree-log code.
2045 */
2046 mutex_lock(&root->fs_info->tree_log_mutex);
Zheng Yan1a40e232008-09-26 10:09:34 -04002047
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002048 ret = commit_fs_roots(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002049 if (ret) {
2050 mutex_unlock(&root->fs_info->tree_log_mutex);
David Sterba871383b2012-04-02 18:31:37 +02002051 mutex_unlock(&root->fs_info->reloc_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08002052 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002053 }
Chris Mason54aa1f42007-06-22 14:16:25 -04002054
Qu Wenruo3818aea2014-01-13 13:36:06 +08002055 /*
David Sterba7e1876a2014-02-05 15:26:17 +01002056 * Since the transaction is done, we can apply the pending changes
2057 * before the next transaction.
Qu Wenruo3818aea2014-01-13 13:36:06 +08002058 */
David Sterba572d9ab2014-02-05 15:26:17 +01002059 btrfs_apply_pending_changes(root->fs_info);
Qu Wenruo3818aea2014-01-13 13:36:06 +08002060
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002061 /* commit_fs_roots gets rid of all the tree log roots, it is now
Chris Masone02119d2008-09-05 16:13:11 -04002062 * safe to free the root of tree log roots
2063 */
2064 btrfs_free_log_root_tree(trans, root->fs_info);
2065
Qu Wenruo0ed47922015-04-16 16:55:08 +08002066 /*
2067 * Since fs roots are all committed, we can get a quite accurate
2068 * new_roots. So let's do quota accounting.
2069 */
2070 ret = btrfs_qgroup_account_extents(trans, root->fs_info);
2071 if (ret < 0) {
2072 mutex_unlock(&root->fs_info->tree_log_mutex);
2073 mutex_unlock(&root->fs_info->reloc_mutex);
2074 goto scrub_continue;
2075 }
2076
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002077 ret = commit_cowonly_roots(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002078 if (ret) {
2079 mutex_unlock(&root->fs_info->tree_log_mutex);
David Sterba871383b2012-04-02 18:31:37 +02002080 mutex_unlock(&root->fs_info->reloc_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08002081 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002082 }
Chris Mason54aa1f42007-06-22 14:16:25 -04002083
Miao Xie2cba30f2013-01-15 06:29:12 +00002084 /*
2085 * The tasks which save the space cache and inode cache may also
2086 * update ->aborted, check it.
2087 */
2088 if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
2089 ret = cur_trans->aborted;
2090 mutex_unlock(&root->fs_info->tree_log_mutex);
2091 mutex_unlock(&root->fs_info->reloc_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08002092 goto scrub_continue;
Miao Xie2cba30f2013-01-15 06:29:12 +00002093 }
2094
Yan Zheng11833d62009-09-11 16:11:19 -04002095 btrfs_prepare_extent_commit(trans, root);
2096
Chris Mason78fae272007-03-25 11:35:08 -04002097 cur_trans = root->fs_info->running_transaction;
Chris Mason5f39d392007-10-15 16:14:19 -04002098
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002099 btrfs_set_root_node(&root->fs_info->tree_root->root_item,
2100 root->fs_info->tree_root->node);
Josef Bacik9e351cc2014-03-13 15:42:13 -04002101 list_add_tail(&root->fs_info->tree_root->dirty_list,
2102 &cur_trans->switch_commits);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002103
2104 btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
2105 root->fs_info->chunk_root->node);
Josef Bacik9e351cc2014-03-13 15:42:13 -04002106 list_add_tail(&root->fs_info->chunk_root->dirty_list,
2107 &cur_trans->switch_commits);
2108
2109 switch_commit_roots(cur_trans, root->fs_info);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002110
Jan Schmidtedf39272012-06-28 18:04:55 +02002111 assert_qgroups_uptodate(trans);
Josef Bacikce93ec52014-11-17 15:45:48 -05002112 ASSERT(list_empty(&cur_trans->dirty_bgs));
Chris Mason1bbc6212015-04-06 12:46:08 -07002113 ASSERT(list_empty(&cur_trans->io_bgs));
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002114 update_super_roots(root);
Chris Masone02119d2008-09-05 16:13:11 -04002115
Josef Bacik60e7cd32013-09-30 14:10:43 -04002116 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
2117 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
David Sterba6c417612011-04-13 15:41:04 +02002118 memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
2119 sizeof(*root->fs_info->super_copy));
Chris Masonccd467d2007-06-28 15:57:36 -04002120
Miao Xie935e5cc2014-09-03 21:35:33 +08002121 btrfs_update_commit_device_size(root->fs_info);
Miao Xiece7213c2014-09-03 21:35:34 +08002122 btrfs_update_commit_device_bytes_used(root, cur_trans);
Miao Xie935e5cc2014-09-03 21:35:33 +08002123
Filipe Manana656f30d2014-09-26 12:25:56 +01002124 clear_bit(BTRFS_INODE_BTREE_LOG1_ERR, &btree_ino->runtime_flags);
2125 clear_bit(BTRFS_INODE_BTREE_LOG2_ERR, &btree_ino->runtime_flags);
2126
Filipe Manana4fbcdf62015-05-20 14:01:54 +01002127 btrfs_trans_release_chunk_metadata(trans);
2128
Josef Bacika4abeea2011-04-11 17:25:13 -04002129 spin_lock(&root->fs_info->trans_lock);
Miao Xie4a9d8bd2013-05-17 03:53:43 +00002130 cur_trans->state = TRANS_STATE_UNBLOCKED;
Josef Bacika4abeea2011-04-11 17:25:13 -04002131 root->fs_info->running_transaction = NULL;
Josef Bacika4abeea2011-04-11 17:25:13 -04002132 spin_unlock(&root->fs_info->trans_lock);
Chris Mason75857172011-06-13 20:00:16 -04002133 mutex_unlock(&root->fs_info->reloc_mutex);
Chris Masonb7ec40d2009-03-12 20:12:45 -04002134
Chris Masonf9295742008-07-17 12:54:14 -04002135 wake_up(&root->fs_info->transaction_wait);
Chris Masone6dcd2d2008-07-17 12:53:50 -04002136
Chris Mason79154b12007-03-22 15:59:16 -04002137 ret = btrfs_write_and_wait_transaction(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002138 if (ret) {
2139 btrfs_error(root->fs_info, ret,
David Sterba08748812013-03-12 14:46:08 +00002140 "Error while writing out transaction");
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002141 mutex_unlock(&root->fs_info->tree_log_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08002142 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002143 }
2144
2145 ret = write_ctree_super(trans, root, 0);
2146 if (ret) {
2147 mutex_unlock(&root->fs_info->tree_log_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08002148 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002149 }
Chris Mason4313b392008-01-03 09:08:48 -05002150
Chris Masone02119d2008-09-05 16:13:11 -04002151 /*
2152 * the super is written, we can safely allow the tree-loggers
2153 * to go about their business
2154 */
2155 mutex_unlock(&root->fs_info->tree_log_mutex);
2156
Yan Zheng11833d62009-09-11 16:11:19 -04002157 btrfs_finish_extent_commit(trans, root);
Chris Mason4313b392008-01-03 09:08:48 -05002158
Zhao Lei13212b52015-02-12 14:18:17 +08002159 if (cur_trans->have_free_bgs)
2160 btrfs_clear_space_info_full(root->fs_info);
2161
Josef Bacik15ee9bc2007-08-10 16:22:09 -04002162 root->fs_info->last_trans_committed = cur_trans->transid;
Miao Xie4a9d8bd2013-05-17 03:53:43 +00002163 /*
2164 * We needn't acquire the lock here because there is no other task
2165 * which can change it.
2166 */
2167 cur_trans->state = TRANS_STATE_COMPLETED;
Chris Mason2c90e5d2007-04-02 10:50:19 -04002168 wake_up(&cur_trans->commit_wait);
Chris Mason3de45862008-11-17 21:02:50 -05002169
Josef Bacika4abeea2011-04-11 17:25:13 -04002170 spin_lock(&root->fs_info->trans_lock);
Josef Bacik13c5a932011-04-11 15:45:29 -04002171 list_del_init(&cur_trans->list);
Josef Bacika4abeea2011-04-11 17:25:13 -04002172 spin_unlock(&root->fs_info->trans_lock);
2173
Josef Bacik724e2312013-09-30 11:36:38 -04002174 btrfs_put_transaction(cur_trans);
2175 btrfs_put_transaction(cur_trans);
Josef Bacik58176a92007-08-29 15:47:34 -04002176
Miao Xie0860adf2013-05-15 07:48:27 +00002177 if (trans->type & __TRANS_FREEZABLE)
Miao Xie354aa0f2012-09-20 01:54:00 -06002178 sb_end_intwrite(root->fs_info->sb);
Jan Karab2b5ef52012-06-12 16:20:45 +02002179
liubo1abe9b82011-03-24 11:18:59 +00002180 trace_btrfs_transaction_commit(root);
2181
Arne Jansena2de7332011-03-08 14:14:00 +01002182 btrfs_scrub_continue(root);
2183
Josef Bacik9ed74f22009-09-11 16:12:44 -04002184 if (current->journal_info == trans)
2185 current->journal_info = NULL;
2186
Chris Mason2c90e5d2007-04-02 10:50:19 -04002187 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Yan, Zheng24bbcf02009-11-12 09:36:34 +00002188
Zhao Lei8a733012015-07-15 11:48:14 +08002189 if (current != root->fs_info->transaction_kthread &&
2190 current != root->fs_info->cleaner_kthread)
Yan, Zheng24bbcf02009-11-12 09:36:34 +00002191 btrfs_run_delayed_iputs(root);
2192
Chris Mason79154b12007-03-22 15:59:16 -04002193 return ret;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002194
Wang Shilong6cf7f772014-02-19 19:24:16 +08002195scrub_continue:
2196 btrfs_scrub_continue(root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002197cleanup_transaction:
Josef Bacik0e721102012-06-26 16:13:18 -04002198 btrfs_trans_release_metadata(trans, root);
Filipe Manana4fbcdf62015-05-20 14:01:54 +01002199 btrfs_trans_release_chunk_metadata(trans);
Josef Bacik0e721102012-06-26 16:13:18 -04002200 trans->block_rsv = NULL;
Miao Xie272d26d2013-02-20 14:16:39 +00002201 if (trans->qgroup_reserved) {
2202 btrfs_qgroup_free(root, trans->qgroup_reserved);
2203 trans->qgroup_reserved = 0;
2204 }
Simon Kirbyc2cf52e2013-03-19 22:41:23 +00002205 btrfs_warn(root->fs_info, "Skipping commit of aborted transaction.");
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002206 if (current->journal_info == trans)
2207 current->journal_info = NULL;
Josef Bacik7b8b92a2012-05-31 15:52:43 -04002208 cleanup_transaction(trans, root, ret);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002209
2210 return ret;
Chris Mason79154b12007-03-22 15:59:16 -04002211}
2212
Chris Masond352ac62008-09-29 15:18:18 -04002213/*
David Sterba9d1a2a32013-03-12 15:13:28 +00002214 * return < 0 if error
2215 * 0 if there are no more dead_roots at the time of call
2216 * 1 there are more to be processed, call me again
2217 *
2218 * The return value indicates there are certainly more snapshots to delete, but
2219 * if there comes a new one during processing, it may return 0. We don't mind,
2220 * because btrfs_commit_super will poke cleaner thread and it will process it a
2221 * few seconds later.
Chris Masond352ac62008-09-29 15:18:18 -04002222 */
David Sterba9d1a2a32013-03-12 15:13:28 +00002223int btrfs_clean_one_deleted_snapshot(struct btrfs_root *root)
Chris Masone9d0b132007-08-10 14:06:19 -04002224{
David Sterba9d1a2a32013-03-12 15:13:28 +00002225 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002226 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Masone9d0b132007-08-10 14:06:19 -04002227
Josef Bacika4abeea2011-04-11 17:25:13 -04002228 spin_lock(&fs_info->trans_lock);
David Sterba9d1a2a32013-03-12 15:13:28 +00002229 if (list_empty(&fs_info->dead_roots)) {
2230 spin_unlock(&fs_info->trans_lock);
2231 return 0;
2232 }
2233 root = list_first_entry(&fs_info->dead_roots,
2234 struct btrfs_root, root_list);
Josef Bacikcfad3922013-07-25 15:11:47 -04002235 list_del_init(&root->root_list);
Josef Bacika4abeea2011-04-11 17:25:13 -04002236 spin_unlock(&fs_info->trans_lock);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002237
Frank Holtonefe120a2013-12-20 11:37:06 -05002238 pr_debug("BTRFS: cleaner removing %llu\n", root->objectid);
Jeff Mahoney2c536792011-10-03 23:22:41 -04002239
David Sterba9d1a2a32013-03-12 15:13:28 +00002240 btrfs_kill_all_delayed_nodes(root);
Yan, Zheng76dda932009-09-21 16:00:26 -04002241
David Sterba9d1a2a32013-03-12 15:13:28 +00002242 if (btrfs_header_backref_rev(root->node) <
2243 BTRFS_MIXED_BACKREF_REV)
2244 ret = btrfs_drop_snapshot(root, NULL, 0, 0);
2245 else
2246 ret = btrfs_drop_snapshot(root, NULL, 1, 0);
David Sterba32471dc2014-02-05 02:03:47 +01002247
Josef Bacik6596a9282013-07-31 10:28:05 -04002248 return (ret < 0) ? 0 : 1;
Chris Masone9d0b132007-08-10 14:06:19 -04002249}
David Sterba572d9ab2014-02-05 15:26:17 +01002250
2251void btrfs_apply_pending_changes(struct btrfs_fs_info *fs_info)
2252{
2253 unsigned long prev;
2254 unsigned long bit;
2255
Qu Wenruo6c9fe142015-01-20 17:05:33 +08002256 prev = xchg(&fs_info->pending_changes, 0);
David Sterba572d9ab2014-02-05 15:26:17 +01002257 if (!prev)
2258 return;
2259
David Sterba7e1876a2014-02-05 15:26:17 +01002260 bit = 1 << BTRFS_PENDING_SET_INODE_MAP_CACHE;
2261 if (prev & bit)
2262 btrfs_set_opt(fs_info->mount_opt, INODE_MAP_CACHE);
2263 prev &= ~bit;
2264
2265 bit = 1 << BTRFS_PENDING_CLEAR_INODE_MAP_CACHE;
2266 if (prev & bit)
2267 btrfs_clear_opt(fs_info->mount_opt, INODE_MAP_CACHE);
2268 prev &= ~bit;
2269
David Sterbad51033d2014-11-12 14:24:35 +01002270 bit = 1 << BTRFS_PENDING_COMMIT;
2271 if (prev & bit)
2272 btrfs_debug(fs_info, "pending commit done");
2273 prev &= ~bit;
2274
David Sterba572d9ab2014-02-05 15:26:17 +01002275 if (prev)
2276 btrfs_warn(fs_info,
2277 "unknown pending changes left 0x%lx, ignoring", prev);
2278}