blob: 7e80f32550a663e7438d3e5fb8b1c37fcc391b64 [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
Miao Xie4a9d8bd2013-05-17 03:53:43 +000038static unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = {
39 [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 Bacik6df9a952013-06-27 13:22:46 -040067 while (!list_empty(&transaction->pending_chunks)) {
68 struct extent_map *em;
69
70 em = list_first_entry(&transaction->pending_chunks,
71 struct extent_map, list);
72 list_del_init(&em->list);
73 free_extent_map(em);
74 }
Chris Mason2c90e5d2007-04-02 10:50:19 -040075 kmem_cache_free(btrfs_transaction_cachep, transaction);
Chris Mason78fae272007-03-25 11:35:08 -040076 }
Chris Mason79154b12007-03-22 15:59:16 -040077}
78
Filipe Manana663dfbb2014-10-13 12:28:37 +010079static void clear_btree_io_tree(struct extent_io_tree *tree)
80{
81 spin_lock(&tree->lock);
82 while (!RB_EMPTY_ROOT(&tree->state)) {
83 struct rb_node *node;
84 struct extent_state *state;
85
86 node = rb_first(&tree->state);
87 state = rb_entry(node, struct extent_state, rb_node);
88 rb_erase(&state->rb_node, &tree->state);
89 RB_CLEAR_NODE(&state->rb_node);
90 /*
91 * btree io trees aren't supposed to have tasks waiting for
92 * changes in the flags of extent states ever.
93 */
94 ASSERT(!waitqueue_active(&state->wq));
95 free_extent_state(state);
96 if (need_resched()) {
97 spin_unlock(&tree->lock);
98 cond_resched();
99 spin_lock(&tree->lock);
100 }
101 }
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 }
120 up_write(&fs_info->commit_root_sem);
Josef Bacik817d52f2009-07-13 21:29:25 -0400121}
122
Miao Xie0860adf2013-05-15 07:48:27 +0000123static inline void extwriter_counter_inc(struct btrfs_transaction *trans,
124 unsigned int type)
125{
126 if (type & TRANS_EXTWRITERS)
127 atomic_inc(&trans->num_extwriters);
128}
129
130static inline void extwriter_counter_dec(struct btrfs_transaction *trans,
131 unsigned int type)
132{
133 if (type & TRANS_EXTWRITERS)
134 atomic_dec(&trans->num_extwriters);
135}
136
137static inline void extwriter_counter_init(struct btrfs_transaction *trans,
138 unsigned int type)
139{
140 atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0));
141}
142
143static inline int extwriter_counter_read(struct btrfs_transaction *trans)
144{
145 return atomic_read(&trans->num_extwriters);
Miao Xie178260b2013-02-20 09:16:24 +0000146}
147
Chris Masond352ac62008-09-29 15:18:18 -0400148/*
149 * either allocate a new transaction or hop into the existing one
150 */
Miao Xie0860adf2013-05-15 07:48:27 +0000151static noinline int join_transaction(struct btrfs_root *root, unsigned int type)
Chris Mason79154b12007-03-22 15:59:16 -0400152{
153 struct btrfs_transaction *cur_trans;
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200154 struct btrfs_fs_info *fs_info = root->fs_info;
Josef Bacika4abeea2011-04-11 17:25:13 -0400155
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200156 spin_lock(&fs_info->trans_lock);
Chris Masond43317d2011-11-06 03:26:19 -0500157loop:
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100158 /* The file system has been taken offline. No new transactions. */
Miao Xie87533c42013-01-29 10:14:48 +0000159 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200160 spin_unlock(&fs_info->trans_lock);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100161 return -EROFS;
162 }
163
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200164 cur_trans = fs_info->running_transaction;
Josef Bacika4abeea2011-04-11 17:25:13 -0400165 if (cur_trans) {
David Sterba871383b2012-04-02 18:31:37 +0200166 if (cur_trans->aborted) {
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200167 spin_unlock(&fs_info->trans_lock);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100168 return cur_trans->aborted;
David Sterba871383b2012-04-02 18:31:37 +0200169 }
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000170 if (btrfs_blocked_trans_types[cur_trans->state] & type) {
Miao Xie178260b2013-02-20 09:16:24 +0000171 spin_unlock(&fs_info->trans_lock);
172 return -EBUSY;
173 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400174 atomic_inc(&cur_trans->use_count);
Josef Bacik13c5a932011-04-11 15:45:29 -0400175 atomic_inc(&cur_trans->num_writers);
Miao Xie0860adf2013-05-15 07:48:27 +0000176 extwriter_counter_inc(cur_trans, type);
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200177 spin_unlock(&fs_info->trans_lock);
Josef Bacika4abeea2011-04-11 17:25:13 -0400178 return 0;
Chris Mason79154b12007-03-22 15:59:16 -0400179 }
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200180 spin_unlock(&fs_info->trans_lock);
Josef Bacika4abeea2011-04-11 17:25:13 -0400181
Miao Xie354aa0f2012-09-20 01:54:00 -0600182 /*
183 * If we are ATTACH, we just want to catch the current transaction,
184 * and commit it. If there is no transaction, just return ENOENT.
185 */
186 if (type == TRANS_ATTACH)
187 return -ENOENT;
188
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000189 /*
190 * JOIN_NOLOCK only happens during the transaction commit, so
191 * it is impossible that ->running_transaction is NULL
192 */
193 BUG_ON(type == TRANS_JOIN_NOLOCK);
194
Josef Bacika4abeea2011-04-11 17:25:13 -0400195 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
196 if (!cur_trans)
197 return -ENOMEM;
Chris Masond43317d2011-11-06 03:26:19 -0500198
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200199 spin_lock(&fs_info->trans_lock);
200 if (fs_info->running_transaction) {
Chris Masond43317d2011-11-06 03:26:19 -0500201 /*
202 * someone started a transaction after we unlocked. Make sure
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000203 * to redo the checks above
Chris Masond43317d2011-11-06 03:26:19 -0500204 */
Josef Bacika4abeea2011-04-11 17:25:13 -0400205 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
Chris Masond43317d2011-11-06 03:26:19 -0500206 goto loop;
Miao Xie87533c42013-01-29 10:14:48 +0000207 } else if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
Dan Carpentere4b50e12012-06-19 13:30:11 +0300208 spin_unlock(&fs_info->trans_lock);
Josef Bacik7b8b92a2012-05-31 15:52:43 -0400209 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
210 return -EROFS;
Josef Bacika4abeea2011-04-11 17:25:13 -0400211 }
Chris Masond43317d2011-11-06 03:26:19 -0500212
Josef Bacika4abeea2011-04-11 17:25:13 -0400213 atomic_set(&cur_trans->num_writers, 1);
Miao Xie0860adf2013-05-15 07:48:27 +0000214 extwriter_counter_init(cur_trans, type);
Josef Bacika4abeea2011-04-11 17:25:13 -0400215 init_waitqueue_head(&cur_trans->writer_wait);
216 init_waitqueue_head(&cur_trans->commit_wait);
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000217 cur_trans->state = TRANS_STATE_RUNNING;
Josef Bacika4abeea2011-04-11 17:25:13 -0400218 /*
219 * One for this trans handle, one so it will live on until we
220 * commit the transaction.
221 */
222 atomic_set(&cur_trans->use_count, 2);
Zhao Lei13212b52015-02-12 14:18:17 +0800223 cur_trans->have_free_bgs = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -0400224 cur_trans->start_time = get_seconds();
225
Liu Boc46effa2013-10-14 12:59:45 +0800226 cur_trans->delayed_refs.href_root = RB_ROOT;
Josef Bacikd7df2c72014-01-23 09:21:38 -0500227 atomic_set(&cur_trans->delayed_refs.num_entries, 0);
Josef Bacika4abeea2011-04-11 17:25:13 -0400228 cur_trans->delayed_refs.num_heads_ready = 0;
229 cur_trans->delayed_refs.num_heads = 0;
230 cur_trans->delayed_refs.flushing = 0;
231 cur_trans->delayed_refs.run_delayed_start = 0;
Jan Schmidt20b297d2012-05-20 15:43:53 +0200232
233 /*
234 * although the tree mod log is per file system and not per transaction,
235 * the log must never go across transaction boundaries.
236 */
237 smp_mb();
Julia Lawall31b1a2b2012-11-03 10:58:34 +0000238 if (!list_empty(&fs_info->tree_mod_seq_list))
Frank Holtonefe120a2013-12-20 11:37:06 -0500239 WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when "
Jan Schmidt20b297d2012-05-20 15:43:53 +0200240 "creating a fresh transaction\n");
Julia Lawall31b1a2b2012-11-03 10:58:34 +0000241 if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log))
Frank Holtonefe120a2013-12-20 11:37:06 -0500242 WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when "
Jan Schmidt20b297d2012-05-20 15:43:53 +0200243 "creating a fresh transaction\n");
Jan Schmidtfc36ed7e2013-04-24 16:57:33 +0000244 atomic64_set(&fs_info->tree_mod_seq, 0);
Jan Schmidt20b297d2012-05-20 15:43:53 +0200245
Josef Bacika4abeea2011-04-11 17:25:13 -0400246 spin_lock_init(&cur_trans->delayed_refs.lock);
247
248 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
Josef Bacik6df9a952013-06-27 13:22:46 -0400249 INIT_LIST_HEAD(&cur_trans->pending_chunks);
Josef Bacik9e351cc2014-03-13 15:42:13 -0400250 INIT_LIST_HEAD(&cur_trans->switch_commits);
Josef Bacik50d9aa92014-11-21 14:52:38 -0500251 INIT_LIST_HEAD(&cur_trans->pending_ordered);
Josef Bacikce93ec52014-11-17 15:45:48 -0500252 INIT_LIST_HEAD(&cur_trans->dirty_bgs);
253 spin_lock_init(&cur_trans->dirty_bgs_lock);
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200254 list_add_tail(&cur_trans->list, &fs_info->trans_list);
Josef Bacika4abeea2011-04-11 17:25:13 -0400255 extent_io_tree_init(&cur_trans->dirty_pages,
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200256 fs_info->btree_inode->i_mapping);
257 fs_info->generation++;
258 cur_trans->transid = fs_info->generation;
259 fs_info->running_transaction = cur_trans;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100260 cur_trans->aborted = 0;
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200261 spin_unlock(&fs_info->trans_lock);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400262
Chris Mason79154b12007-03-22 15:59:16 -0400263 return 0;
264}
265
Chris Masond352ac62008-09-29 15:18:18 -0400266/*
Chris Masond3977122009-01-05 21:25:51 -0500267 * this does all the record keeping required to make sure that a reference
268 * counted root is properly recorded in a given transaction. This is required
269 * to make sure the old root from before we joined the transaction is deleted
270 * when the transaction commits
Chris Masond352ac62008-09-29 15:18:18 -0400271 */
Chris Mason75857172011-06-13 20:00:16 -0400272static int record_root_in_trans(struct btrfs_trans_handle *trans,
Josef Bacika4abeea2011-04-11 17:25:13 -0400273 struct btrfs_root *root)
Chris Mason6702ed42007-08-07 16:15:09 -0400274{
Miao Xie27cdeb72014-04-02 19:51:05 +0800275 if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) &&
276 root->last_trans < trans->transid) {
Chris Mason6702ed42007-08-07 16:15:09 -0400277 WARN_ON(root == root->fs_info->extent_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400278 WARN_ON(root->commit_root != root->node);
Yan Zheng31153d82008-07-28 15:32:19 -0400279
Chris Mason75857172011-06-13 20:00:16 -0400280 /*
Miao Xie27cdeb72014-04-02 19:51:05 +0800281 * see below for IN_TRANS_SETUP usage rules
Chris Mason75857172011-06-13 20:00:16 -0400282 * we have the reloc mutex held now, so there
283 * is only one writer in this function
284 */
Miao Xie27cdeb72014-04-02 19:51:05 +0800285 set_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state);
Chris Mason75857172011-06-13 20:00:16 -0400286
Miao Xie27cdeb72014-04-02 19:51:05 +0800287 /* make sure readers find IN_TRANS_SETUP before
Chris Mason75857172011-06-13 20:00:16 -0400288 * they find our root->last_trans update
289 */
290 smp_wmb();
291
Josef Bacika4abeea2011-04-11 17:25:13 -0400292 spin_lock(&root->fs_info->fs_roots_radix_lock);
293 if (root->last_trans == trans->transid) {
294 spin_unlock(&root->fs_info->fs_roots_radix_lock);
295 return 0;
296 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400297 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
298 (unsigned long)root->root_key.objectid,
299 BTRFS_ROOT_TRANS_TAG);
Josef Bacika4abeea2011-04-11 17:25:13 -0400300 spin_unlock(&root->fs_info->fs_roots_radix_lock);
Chris Mason75857172011-06-13 20:00:16 -0400301 root->last_trans = trans->transid;
302
303 /* this is pretty tricky. We don't want to
304 * take the relocation lock in btrfs_record_root_in_trans
305 * unless we're really doing the first setup for this root in
306 * this transaction.
307 *
308 * Normally we'd use root->last_trans as a flag to decide
309 * if we want to take the expensive mutex.
310 *
311 * But, we have to set root->last_trans before we
312 * init the relocation root, otherwise, we trip over warnings
313 * in ctree.c. The solution used here is to flag ourselves
Miao Xie27cdeb72014-04-02 19:51:05 +0800314 * with root IN_TRANS_SETUP. When this is 1, we're still
Chris Mason75857172011-06-13 20:00:16 -0400315 * fixing up the reloc trees and everyone must wait.
316 *
317 * When this is zero, they can trust root->last_trans and fly
318 * through btrfs_record_root_in_trans without having to take the
319 * lock. smp_wmb() makes sure that all the writes above are
320 * done before we pop in the zero below
321 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400322 btrfs_init_reloc_root(trans, root);
Chris Masonc7548af2014-06-10 13:06:56 -0700323 smp_mb__before_atomic();
Miao Xie27cdeb72014-04-02 19:51:05 +0800324 clear_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state);
Chris Mason6702ed42007-08-07 16:15:09 -0400325 }
326 return 0;
327}
328
Chris Mason75857172011-06-13 20:00:16 -0400329
330int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
331 struct btrfs_root *root)
332{
Miao Xie27cdeb72014-04-02 19:51:05 +0800333 if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))
Chris Mason75857172011-06-13 20:00:16 -0400334 return 0;
335
336 /*
Miao Xie27cdeb72014-04-02 19:51:05 +0800337 * see record_root_in_trans for comments about IN_TRANS_SETUP usage
Chris Mason75857172011-06-13 20:00:16 -0400338 * and barriers
339 */
340 smp_rmb();
341 if (root->last_trans == trans->transid &&
Miao Xie27cdeb72014-04-02 19:51:05 +0800342 !test_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state))
Chris Mason75857172011-06-13 20:00:16 -0400343 return 0;
344
345 mutex_lock(&root->fs_info->reloc_mutex);
346 record_root_in_trans(trans, root);
347 mutex_unlock(&root->fs_info->reloc_mutex);
348
349 return 0;
350}
351
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000352static inline int is_transaction_blocked(struct btrfs_transaction *trans)
353{
354 return (trans->state >= TRANS_STATE_BLOCKED &&
Josef Bacik501407a2013-06-10 16:47:23 -0400355 trans->state < TRANS_STATE_UNBLOCKED &&
356 !trans->aborted);
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000357}
358
Chris Masond352ac62008-09-29 15:18:18 -0400359/* wait for commit against the current transaction to become unblocked
360 * when this is done, it is safe to start a new transaction, but the current
361 * transaction might not be fully on disk.
362 */
Chris Mason37d1aee2008-07-31 10:48:37 -0400363static void wait_current_trans(struct btrfs_root *root)
Chris Mason79154b12007-03-22 15:59:16 -0400364{
Chris Masonf9295742008-07-17 12:54:14 -0400365 struct btrfs_transaction *cur_trans;
Chris Mason79154b12007-03-22 15:59:16 -0400366
Josef Bacika4abeea2011-04-11 17:25:13 -0400367 spin_lock(&root->fs_info->trans_lock);
Chris Masonf9295742008-07-17 12:54:14 -0400368 cur_trans = root->fs_info->running_transaction;
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000369 if (cur_trans && is_transaction_blocked(cur_trans)) {
Josef Bacik13c5a932011-04-11 15:45:29 -0400370 atomic_inc(&cur_trans->use_count);
Josef Bacika4abeea2011-04-11 17:25:13 -0400371 spin_unlock(&root->fs_info->trans_lock);
Li Zefan72d63ed2011-07-14 03:17:00 +0000372
373 wait_event(root->fs_info->transaction_wait,
Josef Bacik501407a2013-06-10 16:47:23 -0400374 cur_trans->state >= TRANS_STATE_UNBLOCKED ||
375 cur_trans->aborted);
Josef Bacik724e2312013-09-30 11:36:38 -0400376 btrfs_put_transaction(cur_trans);
Josef Bacika4abeea2011-04-11 17:25:13 -0400377 } else {
378 spin_unlock(&root->fs_info->trans_lock);
Chris Masonf9295742008-07-17 12:54:14 -0400379 }
Chris Mason37d1aee2008-07-31 10:48:37 -0400380}
381
Yan, Zhenga22285a2010-05-16 10:48:46 -0400382static int may_wait_transaction(struct btrfs_root *root, int type)
Chris Mason37d1aee2008-07-31 10:48:37 -0400383{
Josef Bacika4abeea2011-04-11 17:25:13 -0400384 if (root->fs_info->log_root_recovering)
385 return 0;
386
387 if (type == TRANS_USERSPACE)
Yan, Zhenga22285a2010-05-16 10:48:46 -0400388 return 1;
Josef Bacika4abeea2011-04-11 17:25:13 -0400389
390 if (type == TRANS_START &&
391 !atomic_read(&root->fs_info->open_ioctl_trans))
392 return 1;
393
Yan, Zhenga22285a2010-05-16 10:48:46 -0400394 return 0;
395}
396
Miao Xie20dd2cb2013-09-25 21:47:45 +0800397static inline bool need_reserve_reloc_root(struct btrfs_root *root)
398{
399 if (!root->fs_info->reloc_ctl ||
Miao Xie27cdeb72014-04-02 19:51:05 +0800400 !test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
Miao Xie20dd2cb2013-09-25 21:47:45 +0800401 root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
402 root->reloc_root)
403 return false;
404
405 return true;
406}
407
Miao Xie08e007d2012-10-16 11:33:38 +0000408static struct btrfs_trans_handle *
Miao Xie0860adf2013-05-15 07:48:27 +0000409start_transaction(struct btrfs_root *root, u64 num_items, unsigned int type,
Miao Xie08e007d2012-10-16 11:33:38 +0000410 enum btrfs_reserve_flush_enum flush)
Yan, Zhenga22285a2010-05-16 10:48:46 -0400411{
412 struct btrfs_trans_handle *h;
413 struct btrfs_transaction *cur_trans;
Josef Bacikb5009942011-06-07 15:07:51 -0400414 u64 num_bytes = 0;
Arne Jansenc5567232011-09-14 15:44:05 +0200415 u64 qgroup_reserved = 0;
Miao Xie20dd2cb2013-09-25 21:47:45 +0800416 bool reloc_reserved = false;
417 int ret;
liuboacce9522011-01-06 19:30:25 +0800418
Filipe Manana46c4e712014-06-24 17:48:28 +0100419 /* Send isn't supposed to start transactions. */
David Sterba2755a0d2014-07-31 00:43:18 +0200420 ASSERT(current->journal_info != BTRFS_SEND_TRANS_STUB);
Filipe Manana46c4e712014-06-24 17:48:28 +0100421
Miao Xie87533c42013-01-29 10:14:48 +0000422 if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state))
liuboacce9522011-01-06 19:30:25 +0800423 return ERR_PTR(-EROFS);
Josef Bacik2a1eb462011-04-13 15:15:59 -0400424
Filipe Manana46c4e712014-06-24 17:48:28 +0100425 if (current->journal_info) {
Miao Xie0860adf2013-05-15 07:48:27 +0000426 WARN_ON(type & TRANS_EXTWRITERS);
Josef Bacik2a1eb462011-04-13 15:15:59 -0400427 h = current->journal_info;
428 h->use_count++;
Miao Xieb7d5b0a2012-11-01 07:32:18 +0000429 WARN_ON(h->use_count > 2);
Josef Bacik2a1eb462011-04-13 15:15:59 -0400430 h->orig_rsv = h->block_rsv;
431 h->block_rsv = NULL;
432 goto got_it;
433 }
Josef Bacikb5009942011-06-07 15:07:51 -0400434
435 /*
436 * Do the reservation before we join the transaction so we can do all
437 * the appropriate flushing if need be.
438 */
439 if (num_items > 0 && root != root->fs_info->chunk_root) {
Arne Jansenc5567232011-09-14 15:44:05 +0200440 if (root->fs_info->quota_enabled &&
441 is_fstree(root->root_key.objectid)) {
David Sterba707e8a02014-06-04 19:22:26 +0200442 qgroup_reserved = num_items * root->nodesize;
Arne Jansenc5567232011-09-14 15:44:05 +0200443 ret = btrfs_qgroup_reserve(root, qgroup_reserved);
444 if (ret)
445 return ERR_PTR(ret);
446 }
447
Josef Bacikb5009942011-06-07 15:07:51 -0400448 num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
Miao Xie20dd2cb2013-09-25 21:47:45 +0800449 /*
450 * Do the reservation for the relocation root creation
451 */
David Sterbaee39b432014-09-30 01:33:33 +0200452 if (need_reserve_reloc_root(root)) {
Miao Xie20dd2cb2013-09-25 21:47:45 +0800453 num_bytes += root->nodesize;
454 reloc_reserved = true;
455 }
456
Miao Xie08e007d2012-10-16 11:33:38 +0000457 ret = btrfs_block_rsv_add(root,
458 &root->fs_info->trans_block_rsv,
459 num_bytes, flush);
Josef Bacikb5009942011-06-07 15:07:51 -0400460 if (ret)
Miao Xie843fcf32013-01-28 12:36:22 +0000461 goto reserve_fail;
Josef Bacikb5009942011-06-07 15:07:51 -0400462 }
Yan, Zhenga22285a2010-05-16 10:48:46 -0400463again:
464 h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
Miao Xie843fcf32013-01-28 12:36:22 +0000465 if (!h) {
466 ret = -ENOMEM;
467 goto alloc_fail;
468 }
Yan, Zhenga22285a2010-05-16 10:48:46 -0400469
Josef Bacik98114652012-09-14 11:22:38 -0400470 /*
471 * If we are JOIN_NOLOCK we're already committing a transaction and
472 * waiting on this guy, so we don't need to do the sb_start_intwrite
473 * because we're already holding a ref. We need this because we could
474 * have raced in and did an fsync() on a file which can kick a commit
475 * and then we deadlock with somebody doing a freeze.
Miao Xie354aa0f2012-09-20 01:54:00 -0600476 *
477 * If we are ATTACH, it means we just want to catch the current
478 * transaction and commit it, so we needn't do sb_start_intwrite().
Josef Bacik98114652012-09-14 11:22:38 -0400479 */
Miao Xie0860adf2013-05-15 07:48:27 +0000480 if (type & __TRANS_FREEZABLE)
Josef Bacik60376ce2012-09-14 10:34:40 -0400481 sb_start_intwrite(root->fs_info->sb);
Jan Karab2b5ef52012-06-12 16:20:45 +0200482
Yan, Zhenga22285a2010-05-16 10:48:46 -0400483 if (may_wait_transaction(root, type))
Chris Mason37d1aee2008-07-31 10:48:37 -0400484 wait_current_trans(root);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400485
Josef Bacika4abeea2011-04-11 17:25:13 -0400486 do {
Miao Xie354aa0f2012-09-20 01:54:00 -0600487 ret = join_transaction(root, type);
Miao Xie178260b2013-02-20 09:16:24 +0000488 if (ret == -EBUSY) {
Josef Bacika4abeea2011-04-11 17:25:13 -0400489 wait_current_trans(root);
Miao Xie178260b2013-02-20 09:16:24 +0000490 if (unlikely(type == TRANS_ATTACH))
491 ret = -ENOENT;
492 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400493 } while (ret == -EBUSY);
494
Tsutomu Itohdb5b4932011-03-23 08:14:16 +0000495 if (ret < 0) {
Miao Xie354aa0f2012-09-20 01:54:00 -0600496 /* We must get the transaction if we are JOIN_NOLOCK. */
497 BUG_ON(type == TRANS_JOIN_NOLOCK);
Miao Xie843fcf32013-01-28 12:36:22 +0000498 goto join_fail;
Tsutomu Itohdb5b4932011-03-23 08:14:16 +0000499 }
Chris Mason0f7d52f2007-04-09 10:42:37 -0400500
Yan, Zhenga22285a2010-05-16 10:48:46 -0400501 cur_trans = root->fs_info->running_transaction;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400502
503 h->transid = cur_trans->transid;
504 h->transaction = cur_trans;
Chris Mason79154b12007-03-22 15:59:16 -0400505 h->blocks_used = 0;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400506 h->bytes_reserved = 0;
Arne Jansend13603e2011-09-13 11:40:09 +0200507 h->root = root;
Chris Mason56bec292009-03-13 10:10:06 -0400508 h->delayed_ref_updates = 0;
Josef Bacik2a1eb462011-04-13 15:15:59 -0400509 h->use_count = 1;
Josef Bacik0e721102012-06-26 16:13:18 -0400510 h->adding_csums = 0;
Yan, Zhengf0486c62010-05-16 10:46:25 -0400511 h->block_rsv = NULL;
Josef Bacik2a1eb462011-04-13 15:15:59 -0400512 h->orig_rsv = NULL;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100513 h->aborted = 0;
Miao Xie4b824902013-02-20 09:13:32 +0000514 h->qgroup_reserved = 0;
Arne Jansenbed92ea2012-06-28 18:03:02 +0200515 h->delayed_ref_elem.seq = 0;
Miao Xiea698d0752012-09-20 01:51:59 -0600516 h->type = type;
Josef Bacikc6b305a2012-12-18 09:16:16 -0500517 h->allocating_chunk = false;
Miao Xie20dd2cb2013-09-25 21:47:45 +0800518 h->reloc_reserved = false;
Josef Bacik5039edd2014-01-15 13:34:13 -0500519 h->sync = false;
Arne Jansenbed92ea2012-06-28 18:03:02 +0200520 INIT_LIST_HEAD(&h->qgroup_ref_list);
Josef Bacikea658ba2012-09-11 16:57:25 -0400521 INIT_LIST_HEAD(&h->new_bgs);
Josef Bacik50d9aa92014-11-21 14:52:38 -0500522 INIT_LIST_HEAD(&h->ordered);
Chris Masonb7ec40d2009-03-12 20:12:45 -0400523
Yan, Zhenga22285a2010-05-16 10:48:46 -0400524 smp_mb();
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000525 if (cur_trans->state >= TRANS_STATE_BLOCKED &&
526 may_wait_transaction(root, type)) {
Filipe Mananaabdd2e82014-06-24 17:46:58 +0100527 current->journal_info = h;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400528 btrfs_commit_transaction(h, root);
529 goto again;
530 }
Josef Bacik9ed74f22009-09-11 16:12:44 -0400531
Josef Bacikb5009942011-06-07 15:07:51 -0400532 if (num_bytes) {
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500533 trace_btrfs_space_reservation(root->fs_info, "transaction",
Liu Bo2bcc0322012-03-29 09:57:44 -0400534 h->transid, num_bytes, 1);
Josef Bacikb5009942011-06-07 15:07:51 -0400535 h->block_rsv = &root->fs_info->trans_block_rsv;
536 h->bytes_reserved = num_bytes;
Miao Xie20dd2cb2013-09-25 21:47:45 +0800537 h->reloc_reserved = reloc_reserved;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400538 }
Miao Xie4b824902013-02-20 09:13:32 +0000539 h->qgroup_reserved = qgroup_reserved;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400540
Josef Bacik2a1eb462011-04-13 15:15:59 -0400541got_it:
Josef Bacika4abeea2011-04-11 17:25:13 -0400542 btrfs_record_root_in_trans(h, root);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400543
544 if (!current->journal_info && type != TRANS_USERSPACE)
545 current->journal_info = h;
Chris Mason79154b12007-03-22 15:59:16 -0400546 return h;
Miao Xie843fcf32013-01-28 12:36:22 +0000547
548join_fail:
Miao Xie0860adf2013-05-15 07:48:27 +0000549 if (type & __TRANS_FREEZABLE)
Miao Xie843fcf32013-01-28 12:36:22 +0000550 sb_end_intwrite(root->fs_info->sb);
551 kmem_cache_free(btrfs_trans_handle_cachep, h);
552alloc_fail:
553 if (num_bytes)
554 btrfs_block_rsv_release(root, &root->fs_info->trans_block_rsv,
555 num_bytes);
556reserve_fail:
557 if (qgroup_reserved)
558 btrfs_qgroup_free(root, qgroup_reserved);
559 return ERR_PTR(ret);
Chris Mason79154b12007-03-22 15:59:16 -0400560}
561
Chris Masonf9295742008-07-17 12:54:14 -0400562struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
Yan, Zhenga22285a2010-05-16 10:48:46 -0400563 int num_items)
Chris Masonf9295742008-07-17 12:54:14 -0400564{
Miao Xie08e007d2012-10-16 11:33:38 +0000565 return start_transaction(root, num_items, TRANS_START,
566 BTRFS_RESERVE_FLUSH_ALL);
Chris Masonf9295742008-07-17 12:54:14 -0400567}
Miao Xie8407aa42012-09-07 01:43:32 -0600568
Miao Xie08e007d2012-10-16 11:33:38 +0000569struct btrfs_trans_handle *btrfs_start_transaction_lflush(
Miao Xie8407aa42012-09-07 01:43:32 -0600570 struct btrfs_root *root, int num_items)
571{
Miao Xie08e007d2012-10-16 11:33:38 +0000572 return start_transaction(root, num_items, TRANS_START,
573 BTRFS_RESERVE_FLUSH_LIMIT);
Miao Xie8407aa42012-09-07 01:43:32 -0600574}
575
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400576struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
Chris Masonf9295742008-07-17 12:54:14 -0400577{
Miao Xie8407aa42012-09-07 01:43:32 -0600578 return start_transaction(root, 0, TRANS_JOIN, 0);
Chris Masonf9295742008-07-17 12:54:14 -0400579}
580
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400581struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
Josef Bacik0af3d002010-06-21 14:48:16 -0400582{
Miao Xie8407aa42012-09-07 01:43:32 -0600583 return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 0);
Josef Bacik0af3d002010-06-21 14:48:16 -0400584}
585
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400586struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
Sage Weil9ca9ee02008-08-04 10:41:27 -0400587{
Miao Xie8407aa42012-09-07 01:43:32 -0600588 return start_transaction(root, 0, TRANS_USERSPACE, 0);
Sage Weil9ca9ee02008-08-04 10:41:27 -0400589}
590
Miao Xied4edf392013-02-20 09:17:06 +0000591/*
592 * btrfs_attach_transaction() - catch the running transaction
593 *
594 * It is used when we want to commit the current the transaction, but
595 * don't want to start a new one.
596 *
597 * Note: If this function return -ENOENT, it just means there is no
598 * running transaction. But it is possible that the inactive transaction
599 * is still in the memory, not fully on disk. If you hope there is no
600 * inactive transaction in the fs when -ENOENT is returned, you should
601 * invoke
602 * btrfs_attach_transaction_barrier()
603 */
Miao Xie354aa0f2012-09-20 01:54:00 -0600604struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root)
Josef Bacik60376ce2012-09-14 10:34:40 -0400605{
Miao Xie354aa0f2012-09-20 01:54:00 -0600606 return start_transaction(root, 0, TRANS_ATTACH, 0);
Josef Bacik60376ce2012-09-14 10:34:40 -0400607}
608
Miao Xied4edf392013-02-20 09:17:06 +0000609/*
Wang Sheng-Hui90b6d282013-06-14 16:21:24 +0800610 * btrfs_attach_transaction_barrier() - catch the running transaction
Miao Xied4edf392013-02-20 09:17:06 +0000611 *
612 * It is similar to the above function, the differentia is this one
613 * will wait for all the inactive transactions until they fully
614 * complete.
615 */
616struct btrfs_trans_handle *
617btrfs_attach_transaction_barrier(struct btrfs_root *root)
618{
619 struct btrfs_trans_handle *trans;
620
621 trans = start_transaction(root, 0, TRANS_ATTACH, 0);
622 if (IS_ERR(trans) && PTR_ERR(trans) == -ENOENT)
623 btrfs_wait_for_commit(root, 0);
624
625 return trans;
626}
627
Chris Masond352ac62008-09-29 15:18:18 -0400628/* wait for a transaction commit to be fully complete */
Li Zefanb9c83002011-07-14 03:17:14 +0000629static noinline void wait_for_commit(struct btrfs_root *root,
Chris Mason89ce8a62008-06-25 16:01:31 -0400630 struct btrfs_transaction *commit)
631{
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000632 wait_event(commit->commit_wait, commit->state == TRANS_STATE_COMPLETED);
Chris Mason89ce8a62008-06-25 16:01:31 -0400633}
634
Sage Weil46204592010-10-29 15:41:32 -0400635int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
636{
637 struct btrfs_transaction *cur_trans = NULL, *t;
Miao Xie8cd28072012-11-26 08:42:07 +0000638 int ret = 0;
Sage Weil46204592010-10-29 15:41:32 -0400639
Sage Weil46204592010-10-29 15:41:32 -0400640 if (transid) {
641 if (transid <= root->fs_info->last_trans_committed)
Josef Bacika4abeea2011-04-11 17:25:13 -0400642 goto out;
Sage Weil46204592010-10-29 15:41:32 -0400643
644 /* find specified transaction */
Josef Bacika4abeea2011-04-11 17:25:13 -0400645 spin_lock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400646 list_for_each_entry(t, &root->fs_info->trans_list, list) {
647 if (t->transid == transid) {
648 cur_trans = t;
Josef Bacika4abeea2011-04-11 17:25:13 -0400649 atomic_inc(&cur_trans->use_count);
Miao Xie8cd28072012-11-26 08:42:07 +0000650 ret = 0;
Sage Weil46204592010-10-29 15:41:32 -0400651 break;
652 }
Miao Xie8cd28072012-11-26 08:42:07 +0000653 if (t->transid > transid) {
654 ret = 0;
Sage Weil46204592010-10-29 15:41:32 -0400655 break;
Miao Xie8cd28072012-11-26 08:42:07 +0000656 }
Sage Weil46204592010-10-29 15:41:32 -0400657 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400658 spin_unlock(&root->fs_info->trans_lock);
Sage Weil42383022014-09-26 08:30:06 -0700659
660 /*
661 * The specified transaction doesn't exist, or we
662 * raced with btrfs_commit_transaction
663 */
664 if (!cur_trans) {
665 if (transid > root->fs_info->last_trans_committed)
666 ret = -EINVAL;
Miao Xie8cd28072012-11-26 08:42:07 +0000667 goto out;
Sage Weil42383022014-09-26 08:30:06 -0700668 }
Sage Weil46204592010-10-29 15:41:32 -0400669 } else {
670 /* find newest transaction that is committing | committed */
Josef Bacika4abeea2011-04-11 17:25:13 -0400671 spin_lock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400672 list_for_each_entry_reverse(t, &root->fs_info->trans_list,
673 list) {
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000674 if (t->state >= TRANS_STATE_COMMIT_START) {
675 if (t->state == TRANS_STATE_COMPLETED)
Josef Bacik3473f3c2011-06-09 10:15:17 -0400676 break;
Sage Weil46204592010-10-29 15:41:32 -0400677 cur_trans = t;
Josef Bacika4abeea2011-04-11 17:25:13 -0400678 atomic_inc(&cur_trans->use_count);
Sage Weil46204592010-10-29 15:41:32 -0400679 break;
680 }
681 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400682 spin_unlock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400683 if (!cur_trans)
Josef Bacika4abeea2011-04-11 17:25:13 -0400684 goto out; /* nothing committing|committed */
Sage Weil46204592010-10-29 15:41:32 -0400685 }
686
Sage Weil46204592010-10-29 15:41:32 -0400687 wait_for_commit(root, cur_trans);
Josef Bacik724e2312013-09-30 11:36:38 -0400688 btrfs_put_transaction(cur_trans);
Josef Bacika4abeea2011-04-11 17:25:13 -0400689out:
Sage Weil46204592010-10-29 15:41:32 -0400690 return ret;
691}
692
Chris Mason37d1aee2008-07-31 10:48:37 -0400693void btrfs_throttle(struct btrfs_root *root)
694{
Josef Bacika4abeea2011-04-11 17:25:13 -0400695 if (!atomic_read(&root->fs_info->open_ioctl_trans))
Sage Weil9ca9ee02008-08-04 10:41:27 -0400696 wait_current_trans(root);
Chris Mason37d1aee2008-07-31 10:48:37 -0400697}
698
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400699static int should_end_transaction(struct btrfs_trans_handle *trans,
700 struct btrfs_root *root)
701{
Josef Bacik1be41b72013-06-12 13:56:06 -0400702 if (root->fs_info->global_block_rsv.space_info->full &&
Josef Bacik0a2b2a82014-01-23 10:54:11 -0500703 btrfs_check_space_for_delayed_refs(trans, root))
Josef Bacik1be41b72013-06-12 13:56:06 -0400704 return 1;
Josef Bacik36ba0222011-10-18 12:15:48 -0400705
Josef Bacik1be41b72013-06-12 13:56:06 -0400706 return !!btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400707}
708
709int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
710 struct btrfs_root *root)
711{
712 struct btrfs_transaction *cur_trans = trans->transaction;
713 int updates;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100714 int err;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400715
Josef Bacika4abeea2011-04-11 17:25:13 -0400716 smp_mb();
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000717 if (cur_trans->state >= TRANS_STATE_BLOCKED ||
718 cur_trans->delayed_refs.flushing)
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400719 return 1;
720
721 updates = trans->delayed_ref_updates;
722 trans->delayed_ref_updates = 0;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100723 if (updates) {
724 err = btrfs_run_delayed_refs(trans, root, updates);
725 if (err) /* Error code will also eval true */
726 return err;
727 }
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400728
729 return should_end_transaction(trans, root);
730}
731
Chris Mason89ce8a62008-06-25 16:01:31 -0400732static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
Miao Xiea698d0752012-09-20 01:51:59 -0600733 struct btrfs_root *root, int throttle)
Chris Mason79154b12007-03-22 15:59:16 -0400734{
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400735 struct btrfs_transaction *cur_trans = trans->transaction;
Chris Masonab78c842008-07-29 16:15:18 -0400736 struct btrfs_fs_info *info = root->fs_info;
Josef Bacik1be41b72013-06-12 13:56:06 -0400737 unsigned long cur = trans->delayed_ref_updates;
Miao Xiea698d0752012-09-20 01:51:59 -0600738 int lock = (trans->type != TRANS_JOIN_NOLOCK);
Dave Jones4edc2ca2012-04-12 16:03:56 -0400739 int err = 0;
Chris Masona79b7d42014-05-22 16:18:52 -0700740 int must_run_delayed_refs = 0;
Chris Masond6e4a422007-04-06 15:37:36 -0400741
Josef Bacik3bbb24b2014-03-06 19:01:07 -0500742 if (trans->use_count > 1) {
743 trans->use_count--;
Josef Bacik2a1eb462011-04-13 15:15:59 -0400744 trans->block_rsv = trans->orig_rsv;
745 return 0;
746 }
747
Josef Bacikb24e03d2011-10-14 14:40:17 -0400748 btrfs_trans_release_metadata(trans, root);
Josef Bacik4c13d752011-08-30 11:31:29 -0400749 trans->block_rsv = NULL;
Arne Jansenc5567232011-09-14 15:44:05 +0200750
Josef Bacikea658ba2012-09-11 16:57:25 -0400751 if (!list_empty(&trans->new_bgs))
752 btrfs_create_pending_block_groups(trans, root);
753
Josef Bacik50d9aa92014-11-21 14:52:38 -0500754 if (!list_empty(&trans->ordered)) {
755 spin_lock(&info->trans_lock);
756 list_splice(&trans->ordered, &cur_trans->pending_ordered);
757 spin_unlock(&info->trans_lock);
758 }
759
Josef Bacik1be41b72013-06-12 13:56:06 -0400760 trans->delayed_ref_updates = 0;
Chris Masona79b7d42014-05-22 16:18:52 -0700761 if (!trans->sync) {
762 must_run_delayed_refs =
763 btrfs_should_throttle_delayed_refs(trans, root);
Josef Bacik0a2b2a82014-01-23 10:54:11 -0500764 cur = max_t(unsigned long, cur, 32);
Chris Masona79b7d42014-05-22 16:18:52 -0700765
766 /*
767 * don't make the caller wait if they are from a NOLOCK
768 * or ATTACH transaction, it will deadlock with commit
769 */
770 if (must_run_delayed_refs == 1 &&
771 (trans->type & (__TRANS_JOIN_NOLOCK | __TRANS_ATTACH)))
772 must_run_delayed_refs = 2;
Chris Mason56bec292009-03-13 10:10:06 -0400773 }
Chris Masonbb721702013-01-29 18:44:12 -0500774
Josef Bacikfcebe452014-05-13 17:30:47 -0700775 if (trans->qgroup_reserved) {
776 /*
777 * the same root has to be passed here between start_transaction
778 * and end_transaction. Subvolume quota depends on this.
779 */
780 btrfs_qgroup_free(trans->root, trans->qgroup_reserved);
781 trans->qgroup_reserved = 0;
782 }
783
Josef Bacik0e721102012-06-26 16:13:18 -0400784 btrfs_trans_release_metadata(trans, root);
785 trans->block_rsv = NULL;
Chris Mason56bec292009-03-13 10:10:06 -0400786
Josef Bacikea658ba2012-09-11 16:57:25 -0400787 if (!list_empty(&trans->new_bgs))
788 btrfs_create_pending_block_groups(trans, root);
789
Josef Bacika4abeea2011-04-11 17:25:13 -0400790 if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000791 should_end_transaction(trans, root) &&
792 ACCESS_ONCE(cur_trans->state) == TRANS_STATE_RUNNING) {
793 spin_lock(&info->trans_lock);
794 if (cur_trans->state == TRANS_STATE_RUNNING)
795 cur_trans->state = TRANS_STATE_BLOCKED;
796 spin_unlock(&info->trans_lock);
Josef Bacika4abeea2011-04-11 17:25:13 -0400797 }
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400798
Miao Xie4a9d8bd2013-05-17 03:53:43 +0000799 if (lock && ACCESS_ONCE(cur_trans->state) == TRANS_STATE_BLOCKED) {
Josef Bacik3bbb24b2014-03-06 19:01:07 -0500800 if (throttle)
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400801 return btrfs_commit_transaction(trans, root);
Josef Bacik3bbb24b2014-03-06 19:01:07 -0500802 else
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400803 wake_up_process(info->transaction_kthread);
804 }
805
Miao Xie0860adf2013-05-15 07:48:27 +0000806 if (trans->type & __TRANS_FREEZABLE)
Josef Bacik98114652012-09-14 11:22:38 -0400807 sb_end_intwrite(root->fs_info->sb);
Josef Bacik6df78812012-09-05 08:08:30 -0600808
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400809 WARN_ON(cur_trans != info->running_transaction);
Josef Bacik13c5a932011-04-11 15:45:29 -0400810 WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
811 atomic_dec(&cur_trans->num_writers);
Miao Xie0860adf2013-05-15 07:48:27 +0000812 extwriter_counter_dec(cur_trans, trans->type);
Chris Mason89ce8a62008-06-25 16:01:31 -0400813
Sage Weil99d16cb2010-10-29 15:37:34 -0400814 smp_mb();
Chris Mason79154b12007-03-22 15:59:16 -0400815 if (waitqueue_active(&cur_trans->writer_wait))
816 wake_up(&cur_trans->writer_wait);
Josef Bacik724e2312013-09-30 11:36:38 -0400817 btrfs_put_transaction(cur_trans);
Josef Bacik9ed74f22009-09-11 16:12:44 -0400818
819 if (current->journal_info == trans)
820 current->journal_info = NULL;
Chris Masonab78c842008-07-29 16:15:18 -0400821
Yan, Zheng24bbcf02009-11-12 09:36:34 +0000822 if (throttle)
823 btrfs_run_delayed_iputs(root);
824
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100825 if (trans->aborted ||
Josef Bacik4e121c02013-09-27 16:32:39 -0400826 test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
827 wake_up_process(info->transaction_kthread);
Dave Jones4edc2ca2012-04-12 16:03:56 -0400828 err = -EIO;
Josef Bacik4e121c02013-09-27 16:32:39 -0400829 }
Jan Schmidtedf39272012-06-28 18:04:55 +0200830 assert_qgroups_uptodate(trans);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100831
Dave Jones4edc2ca2012-04-12 16:03:56 -0400832 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Chris Masona79b7d42014-05-22 16:18:52 -0700833 if (must_run_delayed_refs) {
834 btrfs_async_run_delayed_refs(root, cur,
835 must_run_delayed_refs == 1);
836 }
Dave Jones4edc2ca2012-04-12 16:03:56 -0400837 return err;
Chris Mason79154b12007-03-22 15:59:16 -0400838}
839
Chris Mason89ce8a62008-06-25 16:01:31 -0400840int btrfs_end_transaction(struct btrfs_trans_handle *trans,
841 struct btrfs_root *root)
842{
Wang Shilong98ad43be2013-04-14 14:08:49 +0000843 return __btrfs_end_transaction(trans, root, 0);
Chris Mason89ce8a62008-06-25 16:01:31 -0400844}
845
846int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
847 struct btrfs_root *root)
848{
Wang Shilong98ad43be2013-04-14 14:08:49 +0000849 return __btrfs_end_transaction(trans, root, 1);
Miao Xie16cdcec2011-04-22 18:12:22 +0800850}
851
Chris Masond352ac62008-09-29 15:18:18 -0400852/*
853 * when btree blocks are allocated, they have some corresponding bits set for
854 * them in one of two extent_io trees. This is used to make sure all of
Chris Mason690587d2009-10-13 13:29:19 -0400855 * those extents are sent to disk but does not wait on them
Chris Masond352ac62008-09-29 15:18:18 -0400856 */
Chris Mason690587d2009-10-13 13:29:19 -0400857int btrfs_write_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000858 struct extent_io_tree *dirty_pages, int mark)
Chris Mason79154b12007-03-22 15:59:16 -0400859{
Chris Mason777e6bd2008-08-15 15:34:15 -0400860 int err = 0;
Chris Mason7c4452b2007-04-28 09:29:35 -0400861 int werr = 0;
Josef Bacik17283662011-09-26 13:58:47 -0400862 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
Josef Bacike6138872012-09-27 17:07:30 -0400863 struct extent_state *cached_state = NULL;
Chris Mason777e6bd2008-08-15 15:34:15 -0400864 u64 start = 0;
Chris Mason5f39d392007-10-15 16:14:19 -0400865 u64 end;
Chris Mason7c4452b2007-04-28 09:29:35 -0400866
Josef Bacik17283662011-09-26 13:58:47 -0400867 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
Josef Bacike6138872012-09-27 17:07:30 -0400868 mark, &cached_state)) {
Filipe Manana663dfbb2014-10-13 12:28:37 +0100869 bool wait_writeback = false;
870
871 err = convert_extent_bit(dirty_pages, start, end,
872 EXTENT_NEED_WAIT,
873 mark, &cached_state, GFP_NOFS);
874 /*
875 * convert_extent_bit can return -ENOMEM, which is most of the
876 * time a temporary error. So when it happens, ignore the error
877 * and wait for writeback of this range to finish - because we
878 * failed to set the bit EXTENT_NEED_WAIT for the range, a call
879 * to btrfs_wait_marked_extents() would not know that writeback
880 * for this range started and therefore wouldn't wait for it to
881 * finish - we don't want to commit a superblock that points to
882 * btree nodes/leafs for which writeback hasn't finished yet
883 * (and without errors).
884 * We cleanup any entries left in the io tree when committing
885 * the transaction (through clear_btree_io_tree()).
886 */
887 if (err == -ENOMEM) {
888 err = 0;
889 wait_writeback = true;
890 }
891 if (!err)
892 err = filemap_fdatawrite_range(mapping, start, end);
Josef Bacik17283662011-09-26 13:58:47 -0400893 if (err)
894 werr = err;
Filipe Manana663dfbb2014-10-13 12:28:37 +0100895 else if (wait_writeback)
896 werr = filemap_fdatawait_range(mapping, start, end);
Filipe Mananae38e2ed2014-10-13 12:28:38 +0100897 free_extent_state(cached_state);
Filipe Manana663dfbb2014-10-13 12:28:37 +0100898 cached_state = NULL;
Josef Bacik17283662011-09-26 13:58:47 -0400899 cond_resched();
900 start = end + 1;
Chris Mason7c4452b2007-04-28 09:29:35 -0400901 }
Chris Mason690587d2009-10-13 13:29:19 -0400902 return werr;
903}
904
905/*
906 * when btree blocks are allocated, they have some corresponding bits set for
907 * them in one of two extent_io trees. This is used to make sure all of
908 * those extents are on disk for transaction or log commit. We wait
909 * on all the pages and clear them from the dirty pages state tree
910 */
911int btrfs_wait_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000912 struct extent_io_tree *dirty_pages, int mark)
Chris Mason690587d2009-10-13 13:29:19 -0400913{
Chris Mason690587d2009-10-13 13:29:19 -0400914 int err = 0;
915 int werr = 0;
Josef Bacik17283662011-09-26 13:58:47 -0400916 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
Josef Bacike6138872012-09-27 17:07:30 -0400917 struct extent_state *cached_state = NULL;
Chris Mason690587d2009-10-13 13:29:19 -0400918 u64 start = 0;
919 u64 end;
Filipe Manana656f30d2014-09-26 12:25:56 +0100920 struct btrfs_inode *btree_ino = BTRFS_I(root->fs_info->btree_inode);
921 bool errors = false;
Chris Mason690587d2009-10-13 13:29:19 -0400922
Josef Bacik17283662011-09-26 13:58:47 -0400923 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
Josef Bacike6138872012-09-27 17:07:30 -0400924 EXTENT_NEED_WAIT, &cached_state)) {
Filipe Manana663dfbb2014-10-13 12:28:37 +0100925 /*
926 * Ignore -ENOMEM errors returned by clear_extent_bit().
927 * When committing the transaction, we'll remove any entries
928 * left in the io tree. For a log commit, we don't remove them
929 * after committing the log because the tree can be accessed
930 * concurrently - we do it only at transaction commit time when
931 * it's safe to do it (through clear_btree_io_tree()).
932 */
933 err = clear_extent_bit(dirty_pages, start, end,
934 EXTENT_NEED_WAIT,
935 0, 0, &cached_state, GFP_NOFS);
936 if (err == -ENOMEM)
937 err = 0;
938 if (!err)
939 err = filemap_fdatawait_range(mapping, start, end);
Josef Bacik17283662011-09-26 13:58:47 -0400940 if (err)
941 werr = err;
Filipe Mananae38e2ed2014-10-13 12:28:38 +0100942 free_extent_state(cached_state);
943 cached_state = NULL;
Josef Bacik17283662011-09-26 13:58:47 -0400944 cond_resched();
945 start = end + 1;
Chris Mason777e6bd2008-08-15 15:34:15 -0400946 }
Chris Mason7c4452b2007-04-28 09:29:35 -0400947 if (err)
948 werr = err;
Filipe Manana656f30d2014-09-26 12:25:56 +0100949
950 if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
951 if ((mark & EXTENT_DIRTY) &&
952 test_and_clear_bit(BTRFS_INODE_BTREE_LOG1_ERR,
953 &btree_ino->runtime_flags))
954 errors = true;
955
956 if ((mark & EXTENT_NEW) &&
957 test_and_clear_bit(BTRFS_INODE_BTREE_LOG2_ERR,
958 &btree_ino->runtime_flags))
959 errors = true;
960 } else {
961 if (test_and_clear_bit(BTRFS_INODE_BTREE_ERR,
962 &btree_ino->runtime_flags))
963 errors = true;
964 }
965
966 if (errors && !werr)
967 werr = -EIO;
968
Chris Mason7c4452b2007-04-28 09:29:35 -0400969 return werr;
Chris Mason79154b12007-03-22 15:59:16 -0400970}
971
Chris Mason690587d2009-10-13 13:29:19 -0400972/*
973 * when btree blocks are allocated, they have some corresponding bits set for
974 * them in one of two extent_io trees. This is used to make sure all of
975 * those extents are on disk for transaction or log commit
976 */
Sergei Trofimovich171170c2013-08-14 23:27:46 +0300977static int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000978 struct extent_io_tree *dirty_pages, int mark)
Chris Mason690587d2009-10-13 13:29:19 -0400979{
980 int ret;
981 int ret2;
Miao Xiec6adc9c2013-05-28 10:05:39 +0000982 struct blk_plug plug;
Chris Mason690587d2009-10-13 13:29:19 -0400983
Miao Xiec6adc9c2013-05-28 10:05:39 +0000984 blk_start_plug(&plug);
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000985 ret = btrfs_write_marked_extents(root, dirty_pages, mark);
Miao Xiec6adc9c2013-05-28 10:05:39 +0000986 blk_finish_plug(&plug);
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000987 ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
Chris Masonbf0da8c2011-11-04 12:29:37 -0400988
989 if (ret)
990 return ret;
991 if (ret2)
992 return ret2;
993 return 0;
Chris Mason690587d2009-10-13 13:29:19 -0400994}
995
Filipe Manana663dfbb2014-10-13 12:28:37 +0100996static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
Chris Masond0c803c2008-09-11 16:17:57 -0400997 struct btrfs_root *root)
998{
Filipe Manana663dfbb2014-10-13 12:28:37 +0100999 int ret;
1000
1001 ret = btrfs_write_and_wait_marked_extents(root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +00001002 &trans->transaction->dirty_pages,
1003 EXTENT_DIRTY);
Filipe Manana663dfbb2014-10-13 12:28:37 +01001004 clear_btree_io_tree(&trans->transaction->dirty_pages);
1005
1006 return ret;
Chris Masond0c803c2008-09-11 16:17:57 -04001007}
1008
Chris Masond352ac62008-09-29 15:18:18 -04001009/*
1010 * this is used to update the root pointer in the tree of tree roots.
1011 *
1012 * But, in the case of the extent allocation tree, updating the root
1013 * pointer may allocate blocks which may change the root of the extent
1014 * allocation tree.
1015 *
1016 * So, this loops and repeats and makes sure the cowonly root didn't
1017 * change while the root pointer was being updated in the metadata.
1018 */
Chris Mason0b86a832008-03-24 15:01:56 -04001019static int update_cowonly_root(struct btrfs_trans_handle *trans,
1020 struct btrfs_root *root)
1021{
1022 int ret;
1023 u64 old_root_bytenr;
Yan, Zheng86b9f2e2009-11-12 09:36:50 +00001024 u64 old_root_used;
Chris Mason0b86a832008-03-24 15:01:56 -04001025 struct btrfs_root *tree_root = root->fs_info->tree_root;
Josef Bacike7070be2014-12-16 08:54:43 -08001026 bool extent_root = (root->objectid == BTRFS_EXTENT_TREE_OBJECTID);
Chris Mason0b86a832008-03-24 15:01:56 -04001027
Yan, Zheng86b9f2e2009-11-12 09:36:50 +00001028 old_root_used = btrfs_root_used(&root->root_item);
Chris Mason0b86a832008-03-24 15:01:56 -04001029 btrfs_write_dirty_block_groups(trans, root);
Chris Mason56bec292009-03-13 10:10:06 -04001030
Chris Masond3977122009-01-05 21:25:51 -05001031 while (1) {
Chris Mason0b86a832008-03-24 15:01:56 -04001032 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
Yan, Zheng86b9f2e2009-11-12 09:36:50 +00001033 if (old_root_bytenr == root->node->start &&
Josef Bacikce93ec52014-11-17 15:45:48 -05001034 old_root_used == btrfs_root_used(&root->root_item) &&
1035 (!extent_root ||
1036 list_empty(&trans->transaction->dirty_bgs)))
Chris Mason0b86a832008-03-24 15:01:56 -04001037 break;
Chris Mason87ef2bb2008-10-30 11:23:27 -04001038
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001039 btrfs_set_root_node(&root->root_item, root->node);
Chris Mason0b86a832008-03-24 15:01:56 -04001040 ret = btrfs_update_root(trans, tree_root,
1041 &root->root_key,
1042 &root->root_item);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001043 if (ret)
1044 return ret;
Chris Mason56bec292009-03-13 10:10:06 -04001045
Yan, Zheng86b9f2e2009-11-12 09:36:50 +00001046 old_root_used = btrfs_root_used(&root->root_item);
Josef Bacike7070be2014-12-16 08:54:43 -08001047 if (extent_root) {
1048 ret = btrfs_write_dirty_block_groups(trans, root);
1049 if (ret)
1050 return ret;
1051 }
1052 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001053 if (ret)
1054 return ret;
Josef Bacikce93ec52014-11-17 15:45:48 -05001055 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Yan Zheng4a8c9a62009-07-22 10:07:05 -04001056 if (ret)
Chris Mason56bec292009-03-13 10:10:06 -04001057 return ret;
Chris Mason0b86a832008-03-24 15:01:56 -04001058 }
Yan Zheng276e6802009-07-30 09:40:40 -04001059
Chris Mason0b86a832008-03-24 15:01:56 -04001060 return 0;
1061}
1062
Chris Masond352ac62008-09-29 15:18:18 -04001063/*
1064 * update all the cowonly tree roots on disk
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001065 *
1066 * The error handling in this function may not be obvious. Any of the
1067 * failures will cause the file system to go offline. We still need
1068 * to clean up the delayed refs.
Chris Masond352ac62008-09-29 15:18:18 -04001069 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001070static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
1071 struct btrfs_root *root)
Chris Mason79154b12007-03-22 15:59:16 -04001072{
Chris Mason79154b12007-03-22 15:59:16 -04001073 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Mason0b86a832008-03-24 15:01:56 -04001074 struct list_head *next;
Yan Zheng84234f32008-10-29 14:49:05 -04001075 struct extent_buffer *eb;
Chris Mason56bec292009-03-13 10:10:06 -04001076 int ret;
Yan Zheng84234f32008-10-29 14:49:05 -04001077
1078 eb = btrfs_lock_root_node(fs_info->tree_root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001079 ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,
1080 0, &eb);
Yan Zheng84234f32008-10-29 14:49:05 -04001081 btrfs_tree_unlock(eb);
1082 free_extent_buffer(eb);
Chris Mason79154b12007-03-22 15:59:16 -04001083
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001084 if (ret)
1085 return ret;
1086
Chris Mason56bec292009-03-13 10:10:06 -04001087 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001088 if (ret)
1089 return ret;
Chris Mason87ef2bb2008-10-30 11:23:27 -04001090
Stefan Behrens733f4fb2012-05-25 16:06:10 +02001091 ret = btrfs_run_dev_stats(trans, root->fs_info);
Josef Bacikc16ce192013-09-27 16:38:20 -04001092 if (ret)
1093 return ret;
Stefan Behrens8dabb742012-11-06 13:15:27 +01001094 ret = btrfs_run_dev_replace(trans, root->fs_info);
Josef Bacikc16ce192013-09-27 16:38:20 -04001095 if (ret)
1096 return ret;
Jan Schmidt546adb02012-06-14 16:37:44 +02001097 ret = btrfs_run_qgroups(trans, root->fs_info);
Josef Bacikc16ce192013-09-27 16:38:20 -04001098 if (ret)
1099 return ret;
Jan Schmidt546adb02012-06-14 16:37:44 +02001100
1101 /* run_qgroups might have added some more refs */
1102 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Josef Bacikc16ce192013-09-27 16:38:20 -04001103 if (ret)
1104 return ret;
Jan Schmidt546adb02012-06-14 16:37:44 +02001105
Chris Masond3977122009-01-05 21:25:51 -05001106 while (!list_empty(&fs_info->dirty_cowonly_roots)) {
Chris Mason0b86a832008-03-24 15:01:56 -04001107 next = fs_info->dirty_cowonly_roots.next;
1108 list_del_init(next);
1109 root = list_entry(next, struct btrfs_root, dirty_list);
Josef Bacike7070be2014-12-16 08:54:43 -08001110 clear_bit(BTRFS_ROOT_DIRTY, &root->state);
Chris Mason87ef2bb2008-10-30 11:23:27 -04001111
Josef Bacik9e351cc2014-03-13 15:42:13 -04001112 if (root != fs_info->extent_root)
1113 list_add_tail(&root->dirty_list,
1114 &trans->transaction->switch_commits);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001115 ret = update_cowonly_root(trans, root);
1116 if (ret)
1117 return ret;
Chris Mason79154b12007-03-22 15:59:16 -04001118 }
Yan Zheng276e6802009-07-30 09:40:40 -04001119
Josef Bacik9e351cc2014-03-13 15:42:13 -04001120 list_add_tail(&fs_info->extent_root->dirty_list,
1121 &trans->transaction->switch_commits);
Stefan Behrens8dabb742012-11-06 13:15:27 +01001122 btrfs_after_dev_replace_commit(fs_info);
1123
Chris Mason79154b12007-03-22 15:59:16 -04001124 return 0;
1125}
1126
Chris Masond352ac62008-09-29 15:18:18 -04001127/*
1128 * dead roots are old snapshots that need to be deleted. This allocates
1129 * a dirty root struct and adds it into the list of dead roots that need to
1130 * be deleted
1131 */
Josef Bacikcfad3922013-07-25 15:11:47 -04001132void btrfs_add_dead_root(struct btrfs_root *root)
Chris Mason5eda7b52007-06-22 14:16:25 -04001133{
Josef Bacika4abeea2011-04-11 17:25:13 -04001134 spin_lock(&root->fs_info->trans_lock);
Josef Bacikcfad3922013-07-25 15:11:47 -04001135 if (list_empty(&root->root_list))
1136 list_add_tail(&root->root_list, &root->fs_info->dead_roots);
Josef Bacika4abeea2011-04-11 17:25:13 -04001137 spin_unlock(&root->fs_info->trans_lock);
Chris Mason5eda7b52007-06-22 14:16:25 -04001138}
1139
Chris Masond352ac62008-09-29 15:18:18 -04001140/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001141 * update all the cowonly tree roots on disk
Chris Masond352ac62008-09-29 15:18:18 -04001142 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001143static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
1144 struct btrfs_root *root)
Chris Mason0f7d52f2007-04-09 10:42:37 -04001145{
Chris Mason0f7d52f2007-04-09 10:42:37 -04001146 struct btrfs_root *gang[8];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001147 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Mason0f7d52f2007-04-09 10:42:37 -04001148 int i;
1149 int ret;
Chris Mason54aa1f42007-06-22 14:16:25 -04001150 int err = 0;
1151
Josef Bacika4abeea2011-04-11 17:25:13 -04001152 spin_lock(&fs_info->fs_roots_radix_lock);
Chris Masond3977122009-01-05 21:25:51 -05001153 while (1) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001154 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
1155 (void **)gang, 0,
Chris Mason0f7d52f2007-04-09 10:42:37 -04001156 ARRAY_SIZE(gang),
1157 BTRFS_ROOT_TRANS_TAG);
1158 if (ret == 0)
1159 break;
1160 for (i = 0; i < ret; i++) {
1161 root = gang[i];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001162 radix_tree_tag_clear(&fs_info->fs_roots_radix,
1163 (unsigned long)root->root_key.objectid,
1164 BTRFS_ROOT_TRANS_TAG);
Josef Bacika4abeea2011-04-11 17:25:13 -04001165 spin_unlock(&fs_info->fs_roots_radix_lock);
Yan Zheng31153d82008-07-28 15:32:19 -04001166
Chris Masone02119d2008-09-05 16:13:11 -04001167 btrfs_free_log(trans, root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001168 btrfs_update_reloc_root(trans, root);
Yan, Zhengd68fc572010-05-16 10:49:58 -04001169 btrfs_orphan_commit_root(trans, root);
Chris Masone02119d2008-09-05 16:13:11 -04001170
Li Zefan82d59022011-04-20 10:33:24 +08001171 btrfs_save_ino_cache(root, trans);
1172
Liu Bof1ebcc72011-11-14 20:48:06 -05001173 /* see comments in should_cow_block() */
Miao Xie27cdeb72014-04-02 19:51:05 +08001174 clear_bit(BTRFS_ROOT_FORCE_COW, &root->state);
Chris Masonc7548af2014-06-10 13:06:56 -07001175 smp_mb__after_atomic();
Liu Bof1ebcc72011-11-14 20:48:06 -05001176
Yan Zheng978d9102009-06-15 20:01:02 -04001177 if (root->commit_root != root->node) {
Josef Bacik9e351cc2014-03-13 15:42:13 -04001178 list_add_tail(&root->dirty_list,
1179 &trans->transaction->switch_commits);
Yan Zheng978d9102009-06-15 20:01:02 -04001180 btrfs_set_root_node(&root->root_item,
1181 root->node);
1182 }
Chris Mason9f3a7422007-08-07 15:52:19 -04001183
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001184 err = btrfs_update_root(trans, fs_info->tree_root,
Chris Mason0f7d52f2007-04-09 10:42:37 -04001185 &root->root_key,
1186 &root->root_item);
Josef Bacika4abeea2011-04-11 17:25:13 -04001187 spin_lock(&fs_info->fs_roots_radix_lock);
Chris Mason54aa1f42007-06-22 14:16:25 -04001188 if (err)
1189 break;
Chris Mason0f7d52f2007-04-09 10:42:37 -04001190 }
1191 }
Josef Bacika4abeea2011-04-11 17:25:13 -04001192 spin_unlock(&fs_info->fs_roots_radix_lock);
Chris Mason54aa1f42007-06-22 14:16:25 -04001193 return err;
Chris Mason0f7d52f2007-04-09 10:42:37 -04001194}
1195
Chris Masond352ac62008-09-29 15:18:18 -04001196/*
Eric Sandeende78b512013-01-31 18:21:12 +00001197 * defrag a given btree.
1198 * Every leaf in the btree is read and defragged.
Chris Masond352ac62008-09-29 15:18:18 -04001199 */
Eric Sandeende78b512013-01-31 18:21:12 +00001200int btrfs_defrag_root(struct btrfs_root *root)
Chris Masone9d0b132007-08-10 14:06:19 -04001201{
1202 struct btrfs_fs_info *info = root->fs_info;
Chris Masone9d0b132007-08-10 14:06:19 -04001203 struct btrfs_trans_handle *trans;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001204 int ret;
Chris Masone9d0b132007-08-10 14:06:19 -04001205
Miao Xie27cdeb72014-04-02 19:51:05 +08001206 if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state))
Chris Masone9d0b132007-08-10 14:06:19 -04001207 return 0;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001208
Chris Mason6b800532007-10-15 16:17:34 -04001209 while (1) {
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001210 trans = btrfs_start_transaction(root, 0);
1211 if (IS_ERR(trans))
1212 return PTR_ERR(trans);
1213
Eric Sandeende78b512013-01-31 18:21:12 +00001214 ret = btrfs_defrag_leaves(trans, root);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001215
Chris Masone9d0b132007-08-10 14:06:19 -04001216 btrfs_end_transaction(trans, root);
Liu Bob53d3f52012-11-14 14:34:34 +00001217 btrfs_btree_balance_dirty(info->tree_root);
Chris Masone9d0b132007-08-10 14:06:19 -04001218 cond_resched();
1219
David Sterba7841cb22011-05-31 18:07:27 +02001220 if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
Chris Masone9d0b132007-08-10 14:06:19 -04001221 break;
David Sterba210549e2013-02-09 23:38:06 +00001222
1223 if (btrfs_defrag_cancelled(root->fs_info)) {
Frank Holtonefe120a2013-12-20 11:37:06 -05001224 pr_debug("BTRFS: defrag_root cancelled\n");
David Sterba210549e2013-02-09 23:38:06 +00001225 ret = -EAGAIN;
1226 break;
1227 }
Chris Masone9d0b132007-08-10 14:06:19 -04001228 }
Miao Xie27cdeb72014-04-02 19:51:05 +08001229 clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001230 return ret;
Chris Masone9d0b132007-08-10 14:06:19 -04001231}
1232
Chris Masond352ac62008-09-29 15:18:18 -04001233/*
1234 * new snapshots need to be created at a very specific time in the
Miao Xieaec80302013-03-04 09:44:29 +00001235 * transaction commit. This does the actual creation.
1236 *
1237 * Note:
1238 * If the error which may affect the commitment of the current transaction
1239 * happens, we should return the error number. If the error which just affect
1240 * the creation of the pending snapshots, just return 0.
Chris Masond352ac62008-09-29 15:18:18 -04001241 */
Chris Mason80b67942008-02-01 16:35:04 -05001242static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
Chris Mason3063d292008-01-08 15:46:30 -05001243 struct btrfs_fs_info *fs_info,
1244 struct btrfs_pending_snapshot *pending)
1245{
1246 struct btrfs_key key;
Chris Mason80b67942008-02-01 16:35:04 -05001247 struct btrfs_root_item *new_root_item;
Chris Mason3063d292008-01-08 15:46:30 -05001248 struct btrfs_root *tree_root = fs_info->tree_root;
1249 struct btrfs_root *root = pending->root;
Sage Weil6bdb72d2010-03-15 17:27:13 +00001250 struct btrfs_root *parent_root;
Liu Bo98c99422011-09-11 10:52:24 -04001251 struct btrfs_block_rsv *rsv;
Sage Weil6bdb72d2010-03-15 17:27:13 +00001252 struct inode *parent_inode;
Miao Xie42874b32012-09-06 04:03:32 -06001253 struct btrfs_path *path;
1254 struct btrfs_dir_item *dir_item;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001255 struct dentry *dentry;
Chris Mason3063d292008-01-08 15:46:30 -05001256 struct extent_buffer *tmp;
Chris Mason925baed2008-06-25 16:01:30 -04001257 struct extent_buffer *old;
Alexander Block8ea05e32012-07-25 17:35:53 +02001258 struct timespec cur_time = CURRENT_TIME;
Miao Xieaec80302013-03-04 09:44:29 +00001259 int ret = 0;
Yan, Zhengd68fc572010-05-16 10:49:58 -04001260 u64 to_reserve = 0;
Sage Weil6bdb72d2010-03-15 17:27:13 +00001261 u64 index = 0;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001262 u64 objectid;
Li Zefanb83cc962010-12-20 16:04:08 +08001263 u64 root_flags;
Alexander Block8ea05e32012-07-25 17:35:53 +02001264 uuid_le new_uuid;
Chris Mason3063d292008-01-08 15:46:30 -05001265
Miao Xie42874b32012-09-06 04:03:32 -06001266 path = btrfs_alloc_path();
1267 if (!path) {
Miao Xieaec80302013-03-04 09:44:29 +00001268 pending->error = -ENOMEM;
1269 return 0;
Miao Xie42874b32012-09-06 04:03:32 -06001270 }
1271
Chris Mason80b67942008-02-01 16:35:04 -05001272 new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
1273 if (!new_root_item) {
Miao Xieaec80302013-03-04 09:44:29 +00001274 pending->error = -ENOMEM;
Miao Xie6fa97002012-09-06 04:00:32 -06001275 goto root_item_alloc_fail;
Chris Mason80b67942008-02-01 16:35:04 -05001276 }
Yan, Zhenga22285a2010-05-16 10:48:46 -04001277
Miao Xieaec80302013-03-04 09:44:29 +00001278 pending->error = btrfs_find_free_objectid(tree_root, &objectid);
1279 if (pending->error)
Miao Xie6fa97002012-09-06 04:00:32 -06001280 goto no_free_objectid;
Chris Mason3063d292008-01-08 15:46:30 -05001281
Yan, Zheng3fd0a552010-05-16 10:49:59 -04001282 btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
Yan, Zhengd68fc572010-05-16 10:49:58 -04001283
1284 if (to_reserve > 0) {
Miao Xieaec80302013-03-04 09:44:29 +00001285 pending->error = btrfs_block_rsv_add(root,
1286 &pending->block_rsv,
1287 to_reserve,
1288 BTRFS_RESERVE_NO_FLUSH);
1289 if (pending->error)
Miao Xie6fa97002012-09-06 04:00:32 -06001290 goto no_free_objectid;
Yan, Zhengd68fc572010-05-16 10:49:58 -04001291 }
1292
Chris Mason3063d292008-01-08 15:46:30 -05001293 key.objectid = objectid;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001294 key.offset = (u64)-1;
1295 key.type = BTRFS_ROOT_ITEM_KEY;
Chris Mason3063d292008-01-08 15:46:30 -05001296
Miao Xie6fa97002012-09-06 04:00:32 -06001297 rsv = trans->block_rsv;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001298 trans->block_rsv = &pending->block_rsv;
Liu Bo2382c5c2013-02-22 04:33:36 +00001299 trans->bytes_reserved = trans->block_rsv->reserved;
Sage Weil6bdb72d2010-03-15 17:27:13 +00001300
Yan, Zhenga22285a2010-05-16 10:48:46 -04001301 dentry = pending->dentry;
Miao Xiee9662f72013-02-28 10:01:15 +00001302 parent_inode = pending->dir;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001303 parent_root = BTRFS_I(parent_inode)->root;
Chris Mason75857172011-06-13 20:00:16 -04001304 record_root_in_trans(trans, parent_root);
Yan, Zhenga22285a2010-05-16 10:48:46 -04001305
Sage Weil6bdb72d2010-03-15 17:27:13 +00001306 /*
1307 * insert the directory item
1308 */
Sage Weil6bdb72d2010-03-15 17:27:13 +00001309 ret = btrfs_set_inode_index(parent_inode, &index);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001310 BUG_ON(ret); /* -ENOMEM */
Miao Xie42874b32012-09-06 04:03:32 -06001311
1312 /* check if there is a file/dir which has the same name. */
1313 dir_item = btrfs_lookup_dir_item(NULL, parent_root, path,
1314 btrfs_ino(parent_inode),
1315 dentry->d_name.name,
1316 dentry->d_name.len, 0);
1317 if (dir_item != NULL && !IS_ERR(dir_item)) {
Chris Masonfe66a052012-02-20 08:40:56 -05001318 pending->error = -EEXIST;
Miao Xieaec80302013-03-04 09:44:29 +00001319 goto dir_item_existed;
Miao Xie42874b32012-09-06 04:03:32 -06001320 } else if (IS_ERR(dir_item)) {
1321 ret = PTR_ERR(dir_item);
Miao Xie8732d442012-09-17 23:52:38 -06001322 btrfs_abort_transaction(trans, root, ret);
1323 goto fail;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001324 }
Miao Xie42874b32012-09-06 04:03:32 -06001325 btrfs_release_path(path);
Sage Weil6bdb72d2010-03-15 17:27:13 +00001326
Chris Masone9993762011-06-17 16:14:09 -04001327 /*
1328 * pull in the delayed directory update
1329 * and the delayed inode item
1330 * otherwise we corrupt the FS during
1331 * snapshot
1332 */
1333 ret = btrfs_run_delayed_items(trans, root);
Miao Xie8732d442012-09-17 23:52:38 -06001334 if (ret) { /* Transaction aborted */
1335 btrfs_abort_transaction(trans, root, ret);
1336 goto fail;
1337 }
Chris Masone9993762011-06-17 16:14:09 -04001338
Chris Mason75857172011-06-13 20:00:16 -04001339 record_root_in_trans(trans, root);
Sage Weil6bdb72d2010-03-15 17:27:13 +00001340 btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
1341 memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
Li Zefan08fe4db2011-03-28 02:01:25 +00001342 btrfs_check_and_init_root_item(new_root_item);
Sage Weil6bdb72d2010-03-15 17:27:13 +00001343
Li Zefanb83cc962010-12-20 16:04:08 +08001344 root_flags = btrfs_root_flags(new_root_item);
1345 if (pending->readonly)
1346 root_flags |= BTRFS_ROOT_SUBVOL_RDONLY;
1347 else
1348 root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY;
1349 btrfs_set_root_flags(new_root_item, root_flags);
1350
Alexander Block8ea05e32012-07-25 17:35:53 +02001351 btrfs_set_root_generation_v2(new_root_item,
1352 trans->transid);
1353 uuid_le_gen(&new_uuid);
1354 memcpy(new_root_item->uuid, new_uuid.b, BTRFS_UUID_SIZE);
1355 memcpy(new_root_item->parent_uuid, root->root_item.uuid,
1356 BTRFS_UUID_SIZE);
Stefan Behrens70023da2013-04-17 09:11:47 +00001357 if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) {
1358 memset(new_root_item->received_uuid, 0,
1359 sizeof(new_root_item->received_uuid));
1360 memset(&new_root_item->stime, 0, sizeof(new_root_item->stime));
1361 memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime));
1362 btrfs_set_root_stransid(new_root_item, 0);
1363 btrfs_set_root_rtransid(new_root_item, 0);
1364 }
Qu Wenruo3cae2102013-07-16 11:19:18 +08001365 btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec);
1366 btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec);
Alexander Block8ea05e32012-07-25 17:35:53 +02001367 btrfs_set_root_otransid(new_root_item, trans->transid);
Alexander Block8ea05e32012-07-25 17:35:53 +02001368
Chris Mason925baed2008-06-25 16:01:30 -04001369 old = btrfs_lock_root_node(root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001370 ret = btrfs_cow_block(trans, root, old, NULL, 0, &old);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001371 if (ret) {
1372 btrfs_tree_unlock(old);
1373 free_extent_buffer(old);
Miao Xie8732d442012-09-17 23:52:38 -06001374 btrfs_abort_transaction(trans, root, ret);
1375 goto fail;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001376 }
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001377
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001378 btrfs_set_lock_blocking(old);
Chris Mason3063d292008-01-08 15:46:30 -05001379
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001380 ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001381 /* clean up in any case */
Chris Mason925baed2008-06-25 16:01:30 -04001382 btrfs_tree_unlock(old);
1383 free_extent_buffer(old);
Miao Xie8732d442012-09-17 23:52:38 -06001384 if (ret) {
1385 btrfs_abort_transaction(trans, root, ret);
1386 goto fail;
1387 }
Chris Mason3063d292008-01-08 15:46:30 -05001388
Josef Bacikfcebe452014-05-13 17:30:47 -07001389 /*
1390 * We need to flush delayed refs in order to make sure all of our quota
1391 * operations have been done before we call btrfs_qgroup_inherit.
1392 */
1393 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1394 if (ret) {
1395 btrfs_abort_transaction(trans, root, ret);
1396 goto fail;
1397 }
1398
Eric Sandeen47a306a2014-06-12 00:53:44 -05001399 ret = btrfs_qgroup_inherit(trans, fs_info,
1400 root->root_key.objectid,
1401 objectid, pending->inherit);
1402 if (ret) {
1403 btrfs_abort_transaction(trans, root, ret);
1404 goto fail;
1405 }
Josef Bacikfcebe452014-05-13 17:30:47 -07001406
Liu Bof1ebcc72011-11-14 20:48:06 -05001407 /* see comments in should_cow_block() */
Miao Xie27cdeb72014-04-02 19:51:05 +08001408 set_bit(BTRFS_ROOT_FORCE_COW, &root->state);
Liu Bof1ebcc72011-11-14 20:48:06 -05001409 smp_wmb();
1410
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001411 btrfs_set_root_node(new_root_item, tmp);
Yan, Zhenga22285a2010-05-16 10:48:46 -04001412 /* record when the snapshot was created in key.offset */
1413 key.offset = trans->transid;
1414 ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
Chris Mason925baed2008-06-25 16:01:30 -04001415 btrfs_tree_unlock(tmp);
Chris Mason3063d292008-01-08 15:46:30 -05001416 free_extent_buffer(tmp);
Miao Xie8732d442012-09-17 23:52:38 -06001417 if (ret) {
1418 btrfs_abort_transaction(trans, root, ret);
1419 goto fail;
1420 }
Chris Mason0660b5a2008-11-17 20:37:39 -05001421
Yan, Zhenga22285a2010-05-16 10:48:46 -04001422 /*
1423 * insert root back/forward references
1424 */
1425 ret = btrfs_add_root_ref(trans, tree_root, objectid,
1426 parent_root->root_key.objectid,
Li Zefan33345d012011-04-20 10:31:50 +08001427 btrfs_ino(parent_inode), index,
Yan, Zhenga22285a2010-05-16 10:48:46 -04001428 dentry->d_name.name, dentry->d_name.len);
Miao Xie8732d442012-09-17 23:52:38 -06001429 if (ret) {
1430 btrfs_abort_transaction(trans, root, ret);
1431 goto fail;
1432 }
Yan, Zhenga22285a2010-05-16 10:48:46 -04001433
1434 key.offset = (u64)-1;
1435 pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001436 if (IS_ERR(pending->snap)) {
1437 ret = PTR_ERR(pending->snap);
Miao Xie8732d442012-09-17 23:52:38 -06001438 btrfs_abort_transaction(trans, root, ret);
1439 goto fail;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001440 }
Yan, Zhengd68fc572010-05-16 10:49:58 -04001441
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001442 ret = btrfs_reloc_post_snapshot(trans, pending);
Miao Xie8732d442012-09-17 23:52:38 -06001443 if (ret) {
1444 btrfs_abort_transaction(trans, root, ret);
1445 goto fail;
1446 }
Miao Xie361048f2012-09-06 04:00:57 -06001447
1448 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Miao Xie8732d442012-09-17 23:52:38 -06001449 if (ret) {
1450 btrfs_abort_transaction(trans, root, ret);
1451 goto fail;
1452 }
Miao Xie42874b32012-09-06 04:03:32 -06001453
1454 ret = btrfs_insert_dir_item(trans, parent_root,
1455 dentry->d_name.name, dentry->d_name.len,
1456 parent_inode, &key,
1457 BTRFS_FT_DIR, index);
1458 /* We have check then name at the beginning, so it is impossible. */
Chris Mason9c520572012-12-17 14:26:57 -05001459 BUG_ON(ret == -EEXIST || ret == -EOVERFLOW);
Miao Xie8732d442012-09-17 23:52:38 -06001460 if (ret) {
1461 btrfs_abort_transaction(trans, root, ret);
1462 goto fail;
1463 }
Miao Xie42874b32012-09-06 04:03:32 -06001464
1465 btrfs_i_size_write(parent_inode, parent_inode->i_size +
1466 dentry->d_name.len * 2);
1467 parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
Josef Bacikbe6aef62012-10-22 15:43:12 -04001468 ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode);
Stefan Behrensdd5f9612013-08-15 17:11:20 +02001469 if (ret) {
Miao Xie8732d442012-09-17 23:52:38 -06001470 btrfs_abort_transaction(trans, root, ret);
Stefan Behrensdd5f9612013-08-15 17:11:20 +02001471 goto fail;
1472 }
1473 ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root, new_uuid.b,
1474 BTRFS_UUID_KEY_SUBVOL, objectid);
1475 if (ret) {
1476 btrfs_abort_transaction(trans, root, ret);
1477 goto fail;
1478 }
1479 if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) {
1480 ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root,
1481 new_root_item->received_uuid,
1482 BTRFS_UUID_KEY_RECEIVED_SUBVOL,
1483 objectid);
1484 if (ret && ret != -EEXIST) {
1485 btrfs_abort_transaction(trans, root, ret);
1486 goto fail;
1487 }
1488 }
Chris Mason3063d292008-01-08 15:46:30 -05001489fail:
Miao Xieaec80302013-03-04 09:44:29 +00001490 pending->error = ret;
1491dir_item_existed:
Liu Bo98c99422011-09-11 10:52:24 -04001492 trans->block_rsv = rsv;
Liu Bo2382c5c2013-02-22 04:33:36 +00001493 trans->bytes_reserved = 0;
Miao Xie6fa97002012-09-06 04:00:32 -06001494no_free_objectid:
1495 kfree(new_root_item);
1496root_item_alloc_fail:
Miao Xie42874b32012-09-06 04:03:32 -06001497 btrfs_free_path(path);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001498 return ret;
Chris Mason3063d292008-01-08 15:46:30 -05001499}
1500
Chris Masond352ac62008-09-29 15:18:18 -04001501/*
1502 * create all the snapshots we've scheduled for creation
1503 */
Chris Mason80b67942008-02-01 16:35:04 -05001504static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
1505 struct btrfs_fs_info *fs_info)
Chris Mason3063d292008-01-08 15:46:30 -05001506{
Miao Xieaec80302013-03-04 09:44:29 +00001507 struct btrfs_pending_snapshot *pending, *next;
Chris Mason3063d292008-01-08 15:46:30 -05001508 struct list_head *head = &trans->transaction->pending_snapshots;
Miao Xieaec80302013-03-04 09:44:29 +00001509 int ret = 0;
Chris Mason3de45862008-11-17 21:02:50 -05001510
Miao Xieaec80302013-03-04 09:44:29 +00001511 list_for_each_entry_safe(pending, next, head, list) {
1512 list_del(&pending->list);
1513 ret = create_pending_snapshot(trans, fs_info, pending);
1514 if (ret)
1515 break;
1516 }
1517 return ret;
Chris Mason3de45862008-11-17 21:02:50 -05001518}
1519
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001520static void update_super_roots(struct btrfs_root *root)
1521{
1522 struct btrfs_root_item *root_item;
1523 struct btrfs_super_block *super;
1524
David Sterba6c417612011-04-13 15:41:04 +02001525 super = root->fs_info->super_copy;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001526
1527 root_item = &root->fs_info->chunk_root->root_item;
1528 super->chunk_root = root_item->bytenr;
1529 super->chunk_root_generation = root_item->generation;
1530 super->chunk_root_level = root_item->level;
1531
1532 root_item = &root->fs_info->tree_root->root_item;
1533 super->root = root_item->bytenr;
1534 super->generation = root_item->generation;
1535 super->root_level = root_item->level;
Josef Bacik73bc1872011-10-03 14:07:49 -04001536 if (btrfs_test_opt(root, SPACE_CACHE))
Josef Bacik0af3d002010-06-21 14:48:16 -04001537 super->cache_generation = root_item->generation;
Stefan Behrens70f80172013-08-15 17:11:23 +02001538 if (root->fs_info->update_uuid_tree_gen)
1539 super->uuid_tree_generation = root_item->generation;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001540}
1541
Chris Masonf36f3042009-07-30 10:04:48 -04001542int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
1543{
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001544 struct btrfs_transaction *trans;
Chris Masonf36f3042009-07-30 10:04:48 -04001545 int ret = 0;
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001546
Josef Bacika4abeea2011-04-11 17:25:13 -04001547 spin_lock(&info->trans_lock);
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001548 trans = info->running_transaction;
1549 if (trans)
1550 ret = (trans->state >= TRANS_STATE_COMMIT_START);
Josef Bacika4abeea2011-04-11 17:25:13 -04001551 spin_unlock(&info->trans_lock);
Chris Masonf36f3042009-07-30 10:04:48 -04001552 return ret;
1553}
1554
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001555int btrfs_transaction_blocked(struct btrfs_fs_info *info)
1556{
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001557 struct btrfs_transaction *trans;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001558 int ret = 0;
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001559
Josef Bacika4abeea2011-04-11 17:25:13 -04001560 spin_lock(&info->trans_lock);
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001561 trans = info->running_transaction;
1562 if (trans)
1563 ret = is_transaction_blocked(trans);
Josef Bacika4abeea2011-04-11 17:25:13 -04001564 spin_unlock(&info->trans_lock);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001565 return ret;
1566}
1567
Sage Weilbb9c12c2010-10-29 15:37:34 -04001568/*
1569 * wait for the current transaction commit to start and block subsequent
1570 * transaction joins
1571 */
1572static void wait_current_trans_commit_start(struct btrfs_root *root,
1573 struct btrfs_transaction *trans)
1574{
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001575 wait_event(root->fs_info->transaction_blocked_wait,
Josef Bacik501407a2013-06-10 16:47:23 -04001576 trans->state >= TRANS_STATE_COMMIT_START ||
1577 trans->aborted);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001578}
1579
1580/*
1581 * wait for the current transaction to start and then become unblocked.
1582 * caller holds ref.
1583 */
1584static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root,
1585 struct btrfs_transaction *trans)
1586{
Li Zefan72d63ed2011-07-14 03:17:00 +00001587 wait_event(root->fs_info->transaction_wait,
Josef Bacik501407a2013-06-10 16:47:23 -04001588 trans->state >= TRANS_STATE_UNBLOCKED ||
1589 trans->aborted);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001590}
1591
1592/*
1593 * commit transactions asynchronously. once btrfs_commit_transaction_async
1594 * returns, any subsequent transaction will not be allowed to join.
1595 */
1596struct btrfs_async_commit {
1597 struct btrfs_trans_handle *newtrans;
1598 struct btrfs_root *root;
Miao Xie7892b5a2012-11-15 08:14:47 +00001599 struct work_struct work;
Sage Weilbb9c12c2010-10-29 15:37:34 -04001600};
1601
1602static void do_async_commit(struct work_struct *work)
1603{
1604 struct btrfs_async_commit *ac =
Miao Xie7892b5a2012-11-15 08:14:47 +00001605 container_of(work, struct btrfs_async_commit, work);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001606
Sage Weil6fc4e35482012-08-30 16:26:15 -06001607 /*
1608 * We've got freeze protection passed with the transaction.
1609 * Tell lockdep about it.
1610 */
Liu Bob1a06a42013-11-06 16:57:55 +08001611 if (ac->newtrans->type & __TRANS_FREEZABLE)
Miao Xieff7c1d32012-11-26 08:41:29 +00001612 rwsem_acquire_read(
1613 &ac->root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
1614 0, 1, _THIS_IP_);
Sage Weil6fc4e35482012-08-30 16:26:15 -06001615
Sage Weile209db72012-08-30 16:26:16 -06001616 current->journal_info = ac->newtrans;
1617
Sage Weilbb9c12c2010-10-29 15:37:34 -04001618 btrfs_commit_transaction(ac->newtrans, ac->root);
1619 kfree(ac);
1620}
1621
1622int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
1623 struct btrfs_root *root,
1624 int wait_for_unblock)
1625{
1626 struct btrfs_async_commit *ac;
1627 struct btrfs_transaction *cur_trans;
1628
1629 ac = kmalloc(sizeof(*ac), GFP_NOFS);
Tsutomu Itohdb5b4932011-03-23 08:14:16 +00001630 if (!ac)
1631 return -ENOMEM;
Sage Weilbb9c12c2010-10-29 15:37:34 -04001632
Miao Xie7892b5a2012-11-15 08:14:47 +00001633 INIT_WORK(&ac->work, do_async_commit);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001634 ac->root = root;
Josef Bacik7a7eaa42011-04-13 12:54:33 -04001635 ac->newtrans = btrfs_join_transaction(root);
Tsutomu Itoh3612b492011-01-25 02:51:38 +00001636 if (IS_ERR(ac->newtrans)) {
1637 int err = PTR_ERR(ac->newtrans);
1638 kfree(ac);
1639 return err;
1640 }
Sage Weilbb9c12c2010-10-29 15:37:34 -04001641
1642 /* take transaction reference */
Sage Weilbb9c12c2010-10-29 15:37:34 -04001643 cur_trans = trans->transaction;
Josef Bacik13c5a932011-04-11 15:45:29 -04001644 atomic_inc(&cur_trans->use_count);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001645
1646 btrfs_end_transaction(trans, root);
Sage Weil6fc4e35482012-08-30 16:26:15 -06001647
1648 /*
1649 * Tell lockdep we've released the freeze rwsem, since the
1650 * async commit thread will be the one to unlock it.
1651 */
Liu Bob1a06a42013-11-06 16:57:55 +08001652 if (ac->newtrans->type & __TRANS_FREEZABLE)
Miao Xieff7c1d32012-11-26 08:41:29 +00001653 rwsem_release(
1654 &root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
1655 1, _THIS_IP_);
Sage Weil6fc4e35482012-08-30 16:26:15 -06001656
Miao Xie7892b5a2012-11-15 08:14:47 +00001657 schedule_work(&ac->work);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001658
1659 /* wait for transaction to start and unblock */
Sage Weilbb9c12c2010-10-29 15:37:34 -04001660 if (wait_for_unblock)
1661 wait_current_trans_commit_start_and_unblock(root, cur_trans);
1662 else
1663 wait_current_trans_commit_start(root, cur_trans);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001664
Sage Weil38e88052011-06-10 18:43:13 +00001665 if (current->journal_info == trans)
1666 current->journal_info = NULL;
1667
Josef Bacik724e2312013-09-30 11:36:38 -04001668 btrfs_put_transaction(cur_trans);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001669 return 0;
1670}
1671
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001672
1673static void cleanup_transaction(struct btrfs_trans_handle *trans,
Josef Bacik7b8b92a2012-05-31 15:52:43 -04001674 struct btrfs_root *root, int err)
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001675{
1676 struct btrfs_transaction *cur_trans = trans->transaction;
Liu Bof094ac32013-02-27 13:28:25 +00001677 DEFINE_WAIT(wait);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001678
1679 WARN_ON(trans->use_count > 1);
1680
Josef Bacik7b8b92a2012-05-31 15:52:43 -04001681 btrfs_abort_transaction(trans, root, err);
1682
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001683 spin_lock(&root->fs_info->trans_lock);
Liu Bo66b61352013-03-04 16:25:41 +00001684
Miao Xie25d8c282013-05-15 07:48:26 +00001685 /*
1686 * If the transaction is removed from the list, it means this
1687 * transaction has been committed successfully, so it is impossible
1688 * to call the cleanup function.
1689 */
1690 BUG_ON(list_empty(&cur_trans->list));
Liu Bo66b61352013-03-04 16:25:41 +00001691
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001692 list_del_init(&cur_trans->list);
Josef Bacikd7096fc2012-05-31 15:49:57 -04001693 if (cur_trans == root->fs_info->running_transaction) {
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001694 cur_trans->state = TRANS_STATE_COMMIT_DOING;
Liu Bof094ac32013-02-27 13:28:25 +00001695 spin_unlock(&root->fs_info->trans_lock);
1696 wait_event(cur_trans->writer_wait,
1697 atomic_read(&cur_trans->num_writers) == 1);
1698
1699 spin_lock(&root->fs_info->trans_lock);
Josef Bacikd7096fc2012-05-31 15:49:57 -04001700 }
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001701 spin_unlock(&root->fs_info->trans_lock);
1702
1703 btrfs_cleanup_one_transaction(trans->transaction, root);
1704
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001705 spin_lock(&root->fs_info->trans_lock);
1706 if (cur_trans == root->fs_info->running_transaction)
1707 root->fs_info->running_transaction = NULL;
1708 spin_unlock(&root->fs_info->trans_lock);
1709
Josef Bacike0228282013-09-20 22:26:29 -04001710 if (trans->type & __TRANS_FREEZABLE)
1711 sb_end_intwrite(root->fs_info->sb);
Josef Bacik724e2312013-09-30 11:36:38 -04001712 btrfs_put_transaction(cur_trans);
1713 btrfs_put_transaction(cur_trans);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001714
1715 trace_btrfs_transaction_commit(root);
1716
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001717 if (current->journal_info == trans)
1718 current->journal_info = NULL;
Wang Shilongc0af8f02014-02-19 19:24:18 +08001719 btrfs_scrub_cancel(root->fs_info);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001720
1721 kmem_cache_free(btrfs_trans_handle_cachep, trans);
1722}
1723
Miao Xie82436612013-05-15 07:48:28 +00001724static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info)
1725{
1726 if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT))
Miao Xie6c255e62014-03-06 13:55:01 +08001727 return btrfs_start_delalloc_roots(fs_info, 1, -1);
Miao Xie82436612013-05-15 07:48:28 +00001728 return 0;
1729}
1730
1731static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info)
1732{
1733 if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT))
Miao Xieb0244192013-11-04 23:13:25 +08001734 btrfs_wait_ordered_roots(fs_info, -1);
Miao Xie82436612013-05-15 07:48:28 +00001735}
1736
Josef Bacik50d9aa92014-11-21 14:52:38 -05001737static inline void
1738btrfs_wait_pending_ordered(struct btrfs_transaction *cur_trans,
1739 struct btrfs_fs_info *fs_info)
1740{
1741 struct btrfs_ordered_extent *ordered;
1742
1743 spin_lock(&fs_info->trans_lock);
1744 while (!list_empty(&cur_trans->pending_ordered)) {
1745 ordered = list_first_entry(&cur_trans->pending_ordered,
1746 struct btrfs_ordered_extent,
1747 trans_list);
1748 list_del_init(&ordered->trans_list);
1749 spin_unlock(&fs_info->trans_lock);
1750
1751 wait_event(ordered->wait, test_bit(BTRFS_ORDERED_COMPLETE,
1752 &ordered->flags));
1753 btrfs_put_ordered_extent(ordered);
1754 spin_lock(&fs_info->trans_lock);
1755 }
1756 spin_unlock(&fs_info->trans_lock);
1757}
1758
Chris Mason79154b12007-03-22 15:59:16 -04001759int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
1760 struct btrfs_root *root)
1761{
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001762 struct btrfs_transaction *cur_trans = trans->transaction;
Chris Mason8fd17792007-04-19 21:01:03 -04001763 struct btrfs_transaction *prev_trans = NULL;
Filipe Manana656f30d2014-09-26 12:25:56 +01001764 struct btrfs_inode *btree_ino = BTRFS_I(root->fs_info->btree_inode);
Miao Xie25287e02012-10-25 09:31:03 +00001765 int ret;
Chris Mason79154b12007-03-22 15:59:16 -04001766
Miao Xie8d25a082013-01-15 06:27:25 +00001767 /* Stop the commit early if ->aborted is set */
1768 if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
Miao Xie25287e02012-10-25 09:31:03 +00001769 ret = cur_trans->aborted;
Josef Bacike4a2bca2013-02-06 16:55:41 -05001770 btrfs_end_transaction(trans, root);
1771 return ret;
Miao Xie25287e02012-10-25 09:31:03 +00001772 }
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001773
Chris Mason56bec292009-03-13 10:10:06 -04001774 /* make a pass through all the delayed refs we have so far
1775 * any runnings procs may add more while we are here
1776 */
1777 ret = btrfs_run_delayed_refs(trans, root, 0);
Josef Bacike4a2bca2013-02-06 16:55:41 -05001778 if (ret) {
1779 btrfs_end_transaction(trans, root);
1780 return ret;
1781 }
Chris Mason56bec292009-03-13 10:10:06 -04001782
Josef Bacik0e721102012-06-26 16:13:18 -04001783 btrfs_trans_release_metadata(trans, root);
1784 trans->block_rsv = NULL;
Miao Xie272d26d2013-02-20 14:16:39 +00001785 if (trans->qgroup_reserved) {
1786 btrfs_qgroup_free(root, trans->qgroup_reserved);
1787 trans->qgroup_reserved = 0;
1788 }
Josef Bacik0e721102012-06-26 16:13:18 -04001789
Chris Masonb7ec40d2009-03-12 20:12:45 -04001790 cur_trans = trans->transaction;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001791
Chris Mason56bec292009-03-13 10:10:06 -04001792 /*
1793 * set the flushing flag so procs in this transaction have to
1794 * start sending their work down.
1795 */
Chris Masonb7ec40d2009-03-12 20:12:45 -04001796 cur_trans->delayed_refs.flushing = 1;
Josef Bacik1be41b72013-06-12 13:56:06 -04001797 smp_wmb();
Chris Mason56bec292009-03-13 10:10:06 -04001798
Josef Bacikea658ba2012-09-11 16:57:25 -04001799 if (!list_empty(&trans->new_bgs))
1800 btrfs_create_pending_block_groups(trans, root);
1801
Chris Masonc3e69d52009-03-13 10:17:05 -04001802 ret = btrfs_run_delayed_refs(trans, root, 0);
Josef Bacike4a2bca2013-02-06 16:55:41 -05001803 if (ret) {
1804 btrfs_end_transaction(trans, root);
1805 return ret;
1806 }
Chris Mason56bec292009-03-13 10:10:06 -04001807
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001808 spin_lock(&root->fs_info->trans_lock);
Josef Bacik50d9aa92014-11-21 14:52:38 -05001809 list_splice(&trans->ordered, &cur_trans->pending_ordered);
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001810 if (cur_trans->state >= TRANS_STATE_COMMIT_START) {
1811 spin_unlock(&root->fs_info->trans_lock);
Josef Bacik13c5a932011-04-11 15:45:29 -04001812 atomic_inc(&cur_trans->use_count);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001813 ret = btrfs_end_transaction(trans, root);
Chris Masonccd467d2007-06-28 15:57:36 -04001814
Li Zefanb9c83002011-07-14 03:17:14 +00001815 wait_for_commit(root, cur_trans);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001816
Josef Bacik724e2312013-09-30 11:36:38 -04001817 btrfs_put_transaction(cur_trans);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001818
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001819 return ret;
Chris Mason79154b12007-03-22 15:59:16 -04001820 }
Chris Mason4313b392008-01-03 09:08:48 -05001821
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001822 cur_trans->state = TRANS_STATE_COMMIT_START;
Sage Weilbb9c12c2010-10-29 15:37:34 -04001823 wake_up(&root->fs_info->transaction_blocked_wait);
1824
Chris Masonccd467d2007-06-28 15:57:36 -04001825 if (cur_trans->list.prev != &root->fs_info->trans_list) {
1826 prev_trans = list_entry(cur_trans->list.prev,
1827 struct btrfs_transaction, list);
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001828 if (prev_trans->state != TRANS_STATE_COMPLETED) {
Josef Bacik13c5a932011-04-11 15:45:29 -04001829 atomic_inc(&prev_trans->use_count);
Josef Bacika4abeea2011-04-11 17:25:13 -04001830 spin_unlock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001831
1832 wait_for_commit(root, prev_trans);
Chris Masonccd467d2007-06-28 15:57:36 -04001833
Josef Bacik724e2312013-09-30 11:36:38 -04001834 btrfs_put_transaction(prev_trans);
Josef Bacika4abeea2011-04-11 17:25:13 -04001835 } else {
1836 spin_unlock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001837 }
Josef Bacika4abeea2011-04-11 17:25:13 -04001838 } else {
1839 spin_unlock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001840 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001841
Miao Xie0860adf2013-05-15 07:48:27 +00001842 extwriter_counter_dec(cur_trans, trans->type);
1843
Miao Xie82436612013-05-15 07:48:28 +00001844 ret = btrfs_start_delalloc_flush(root->fs_info);
1845 if (ret)
1846 goto cleanup_transaction;
1847
Chris Mason8d875f92014-08-12 10:47:42 -07001848 ret = btrfs_run_delayed_items(trans, root);
Miao Xie581227d2013-05-15 07:48:30 +00001849 if (ret)
1850 goto cleanup_transaction;
Chris Mason89573b92009-03-12 20:12:45 -04001851
Miao Xie581227d2013-05-15 07:48:30 +00001852 wait_event(cur_trans->writer_wait,
1853 extwriter_counter_read(cur_trans) == 0);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001854
Miao Xie581227d2013-05-15 07:48:30 +00001855 /* some pending stuffs might be added after the previous flush. */
Chris Mason8d875f92014-08-12 10:47:42 -07001856 ret = btrfs_run_delayed_items(trans, root);
Miao Xieca469632012-11-01 07:33:14 +00001857 if (ret)
1858 goto cleanup_transaction;
1859
Miao Xie82436612013-05-15 07:48:28 +00001860 btrfs_wait_delalloc_flush(root->fs_info);
Wang Shilongcb7ab022013-12-04 21:16:53 +08001861
Josef Bacik50d9aa92014-11-21 14:52:38 -05001862 btrfs_wait_pending_ordered(cur_trans, root->fs_info);
1863
Wang Shilongcb7ab022013-12-04 21:16:53 +08001864 btrfs_scrub_pause(root);
Chris Mason75857172011-06-13 20:00:16 -04001865 /*
Josef Baciked0ca142011-06-14 16:22:15 -04001866 * Ok now we need to make sure to block out any other joins while we
1867 * commit the transaction. We could have started a join before setting
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001868 * COMMIT_DOING so make sure to wait for num_writers to == 1 again.
Josef Baciked0ca142011-06-14 16:22:15 -04001869 */
1870 spin_lock(&root->fs_info->trans_lock);
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001871 cur_trans->state = TRANS_STATE_COMMIT_DOING;
Josef Baciked0ca142011-06-14 16:22:15 -04001872 spin_unlock(&root->fs_info->trans_lock);
1873 wait_event(cur_trans->writer_wait,
1874 atomic_read(&cur_trans->num_writers) == 1);
1875
Miao Xie2cba30f2013-01-15 06:29:12 +00001876 /* ->aborted might be set after the previous check, so check it */
1877 if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
1878 ret = cur_trans->aborted;
Wang Shilong6cf7f772014-02-19 19:24:16 +08001879 goto scrub_continue;
Miao Xie2cba30f2013-01-15 06:29:12 +00001880 }
Chris Masone038dca2011-06-17 14:16:13 -04001881 /*
Chris Mason75857172011-06-13 20:00:16 -04001882 * the reloc mutex makes sure that we stop
1883 * the balancing code from coming in and moving
1884 * extents around in the middle of the commit
1885 */
1886 mutex_lock(&root->fs_info->reloc_mutex);
1887
Miao Xie42874b32012-09-06 04:03:32 -06001888 /*
1889 * We needn't worry about the delayed items because we will
1890 * deal with them in create_pending_snapshot(), which is the
1891 * core function of the snapshot creation.
1892 */
1893 ret = create_pending_snapshots(trans, root->fs_info);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001894 if (ret) {
1895 mutex_unlock(&root->fs_info->reloc_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08001896 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001897 }
Chris Mason3063d292008-01-08 15:46:30 -05001898
Miao Xie42874b32012-09-06 04:03:32 -06001899 /*
1900 * We insert the dir indexes of the snapshots and update the inode
1901 * of the snapshots' parents after the snapshot creation, so there
1902 * are some delayed items which are not dealt with. Now deal with
1903 * them.
1904 *
1905 * We needn't worry that this operation will corrupt the snapshots,
1906 * because all the tree which are snapshoted will be forced to COW
1907 * the nodes and leaves.
1908 */
1909 ret = btrfs_run_delayed_items(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001910 if (ret) {
1911 mutex_unlock(&root->fs_info->reloc_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08001912 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001913 }
Miao Xie16cdcec2011-04-22 18:12:22 +08001914
Chris Mason56bec292009-03-13 10:10:06 -04001915 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001916 if (ret) {
1917 mutex_unlock(&root->fs_info->reloc_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08001918 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001919 }
Chris Mason56bec292009-03-13 10:10:06 -04001920
Chris Masone9993762011-06-17 16:14:09 -04001921 /*
1922 * make sure none of the code above managed to slip in a
1923 * delayed item
1924 */
1925 btrfs_assert_delayed_root_empty(root);
1926
Chris Mason2c90e5d2007-04-02 10:50:19 -04001927 WARN_ON(cur_trans != trans->transaction);
Chris Masondc17ff82008-01-08 15:46:30 -05001928
Chris Masone02119d2008-09-05 16:13:11 -04001929 /* btrfs_commit_tree_roots is responsible for getting the
1930 * various roots consistent with each other. Every pointer
1931 * in the tree of tree roots has to point to the most up to date
1932 * root for every subvolume and other tree. So, we have to keep
1933 * the tree logging code from jumping in and changing any
1934 * of the trees.
1935 *
1936 * At this point in the commit, there can't be any tree-log
1937 * writers, but a little lower down we drop the trans mutex
1938 * and let new people in. By holding the tree_log_mutex
1939 * from now until after the super is written, we avoid races
1940 * with the tree-log code.
1941 */
1942 mutex_lock(&root->fs_info->tree_log_mutex);
Zheng Yan1a40e232008-09-26 10:09:34 -04001943
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001944 ret = commit_fs_roots(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001945 if (ret) {
1946 mutex_unlock(&root->fs_info->tree_log_mutex);
David Sterba871383b2012-04-02 18:31:37 +02001947 mutex_unlock(&root->fs_info->reloc_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08001948 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001949 }
Chris Mason54aa1f42007-06-22 14:16:25 -04001950
Qu Wenruo3818aea2014-01-13 13:36:06 +08001951 /*
David Sterba7e1876a2014-02-05 15:26:17 +01001952 * Since the transaction is done, we can apply the pending changes
1953 * before the next transaction.
Qu Wenruo3818aea2014-01-13 13:36:06 +08001954 */
David Sterba572d9ab2014-02-05 15:26:17 +01001955 btrfs_apply_pending_changes(root->fs_info);
Qu Wenruo3818aea2014-01-13 13:36:06 +08001956
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001957 /* commit_fs_roots gets rid of all the tree log roots, it is now
Chris Masone02119d2008-09-05 16:13:11 -04001958 * safe to free the root of tree log roots
1959 */
1960 btrfs_free_log_root_tree(trans, root->fs_info);
1961
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001962 ret = commit_cowonly_roots(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001963 if (ret) {
1964 mutex_unlock(&root->fs_info->tree_log_mutex);
David Sterba871383b2012-04-02 18:31:37 +02001965 mutex_unlock(&root->fs_info->reloc_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08001966 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001967 }
Chris Mason54aa1f42007-06-22 14:16:25 -04001968
Miao Xie2cba30f2013-01-15 06:29:12 +00001969 /*
1970 * The tasks which save the space cache and inode cache may also
1971 * update ->aborted, check it.
1972 */
1973 if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
1974 ret = cur_trans->aborted;
1975 mutex_unlock(&root->fs_info->tree_log_mutex);
1976 mutex_unlock(&root->fs_info->reloc_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08001977 goto scrub_continue;
Miao Xie2cba30f2013-01-15 06:29:12 +00001978 }
1979
Yan Zheng11833d62009-09-11 16:11:19 -04001980 btrfs_prepare_extent_commit(trans, root);
1981
Chris Mason78fae272007-03-25 11:35:08 -04001982 cur_trans = root->fs_info->running_transaction;
Chris Mason5f39d392007-10-15 16:14:19 -04001983
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001984 btrfs_set_root_node(&root->fs_info->tree_root->root_item,
1985 root->fs_info->tree_root->node);
Josef Bacik9e351cc2014-03-13 15:42:13 -04001986 list_add_tail(&root->fs_info->tree_root->dirty_list,
1987 &cur_trans->switch_commits);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001988
1989 btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
1990 root->fs_info->chunk_root->node);
Josef Bacik9e351cc2014-03-13 15:42:13 -04001991 list_add_tail(&root->fs_info->chunk_root->dirty_list,
1992 &cur_trans->switch_commits);
1993
1994 switch_commit_roots(cur_trans, root->fs_info);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001995
Jan Schmidtedf39272012-06-28 18:04:55 +02001996 assert_qgroups_uptodate(trans);
Josef Bacikce93ec52014-11-17 15:45:48 -05001997 ASSERT(list_empty(&cur_trans->dirty_bgs));
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001998 update_super_roots(root);
Chris Masone02119d2008-09-05 16:13:11 -04001999
Josef Bacik60e7cd32013-09-30 14:10:43 -04002000 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
2001 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
David Sterba6c417612011-04-13 15:41:04 +02002002 memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
2003 sizeof(*root->fs_info->super_copy));
Chris Masonccd467d2007-06-28 15:57:36 -04002004
Miao Xie935e5cc2014-09-03 21:35:33 +08002005 btrfs_update_commit_device_size(root->fs_info);
Miao Xiece7213c2014-09-03 21:35:34 +08002006 btrfs_update_commit_device_bytes_used(root, cur_trans);
Miao Xie935e5cc2014-09-03 21:35:33 +08002007
Filipe Manana656f30d2014-09-26 12:25:56 +01002008 clear_bit(BTRFS_INODE_BTREE_LOG1_ERR, &btree_ino->runtime_flags);
2009 clear_bit(BTRFS_INODE_BTREE_LOG2_ERR, &btree_ino->runtime_flags);
2010
Josef Bacika4abeea2011-04-11 17:25:13 -04002011 spin_lock(&root->fs_info->trans_lock);
Miao Xie4a9d8bd2013-05-17 03:53:43 +00002012 cur_trans->state = TRANS_STATE_UNBLOCKED;
Josef Bacika4abeea2011-04-11 17:25:13 -04002013 root->fs_info->running_transaction = NULL;
Josef Bacika4abeea2011-04-11 17:25:13 -04002014 spin_unlock(&root->fs_info->trans_lock);
Chris Mason75857172011-06-13 20:00:16 -04002015 mutex_unlock(&root->fs_info->reloc_mutex);
Chris Masonb7ec40d2009-03-12 20:12:45 -04002016
Chris Masonf9295742008-07-17 12:54:14 -04002017 wake_up(&root->fs_info->transaction_wait);
Chris Masone6dcd2d2008-07-17 12:53:50 -04002018
Chris Mason79154b12007-03-22 15:59:16 -04002019 ret = btrfs_write_and_wait_transaction(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002020 if (ret) {
2021 btrfs_error(root->fs_info, ret,
David Sterba08748812013-03-12 14:46:08 +00002022 "Error while writing out transaction");
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002023 mutex_unlock(&root->fs_info->tree_log_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08002024 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002025 }
2026
2027 ret = write_ctree_super(trans, root, 0);
2028 if (ret) {
2029 mutex_unlock(&root->fs_info->tree_log_mutex);
Wang Shilong6cf7f772014-02-19 19:24:16 +08002030 goto scrub_continue;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002031 }
Chris Mason4313b392008-01-03 09:08:48 -05002032
Chris Masone02119d2008-09-05 16:13:11 -04002033 /*
2034 * the super is written, we can safely allow the tree-loggers
2035 * to go about their business
2036 */
2037 mutex_unlock(&root->fs_info->tree_log_mutex);
2038
Yan Zheng11833d62009-09-11 16:11:19 -04002039 btrfs_finish_extent_commit(trans, root);
Chris Mason4313b392008-01-03 09:08:48 -05002040
Zhao Lei13212b52015-02-12 14:18:17 +08002041 if (cur_trans->have_free_bgs)
2042 btrfs_clear_space_info_full(root->fs_info);
2043
Josef Bacik15ee9bc2007-08-10 16:22:09 -04002044 root->fs_info->last_trans_committed = cur_trans->transid;
Miao Xie4a9d8bd2013-05-17 03:53:43 +00002045 /*
2046 * We needn't acquire the lock here because there is no other task
2047 * which can change it.
2048 */
2049 cur_trans->state = TRANS_STATE_COMPLETED;
Chris Mason2c90e5d2007-04-02 10:50:19 -04002050 wake_up(&cur_trans->commit_wait);
Chris Mason3de45862008-11-17 21:02:50 -05002051
Josef Bacika4abeea2011-04-11 17:25:13 -04002052 spin_lock(&root->fs_info->trans_lock);
Josef Bacik13c5a932011-04-11 15:45:29 -04002053 list_del_init(&cur_trans->list);
Josef Bacika4abeea2011-04-11 17:25:13 -04002054 spin_unlock(&root->fs_info->trans_lock);
2055
Josef Bacik724e2312013-09-30 11:36:38 -04002056 btrfs_put_transaction(cur_trans);
2057 btrfs_put_transaction(cur_trans);
Josef Bacik58176a92007-08-29 15:47:34 -04002058
Miao Xie0860adf2013-05-15 07:48:27 +00002059 if (trans->type & __TRANS_FREEZABLE)
Miao Xie354aa0f2012-09-20 01:54:00 -06002060 sb_end_intwrite(root->fs_info->sb);
Jan Karab2b5ef52012-06-12 16:20:45 +02002061
liubo1abe9b82011-03-24 11:18:59 +00002062 trace_btrfs_transaction_commit(root);
2063
Arne Jansena2de7332011-03-08 14:14:00 +01002064 btrfs_scrub_continue(root);
2065
Josef Bacik9ed74f22009-09-11 16:12:44 -04002066 if (current->journal_info == trans)
2067 current->journal_info = NULL;
2068
Chris Mason2c90e5d2007-04-02 10:50:19 -04002069 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Yan, Zheng24bbcf02009-11-12 09:36:34 +00002070
2071 if (current != root->fs_info->transaction_kthread)
2072 btrfs_run_delayed_iputs(root);
2073
Chris Mason79154b12007-03-22 15:59:16 -04002074 return ret;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002075
Wang Shilong6cf7f772014-02-19 19:24:16 +08002076scrub_continue:
2077 btrfs_scrub_continue(root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002078cleanup_transaction:
Josef Bacik0e721102012-06-26 16:13:18 -04002079 btrfs_trans_release_metadata(trans, root);
2080 trans->block_rsv = NULL;
Miao Xie272d26d2013-02-20 14:16:39 +00002081 if (trans->qgroup_reserved) {
2082 btrfs_qgroup_free(root, trans->qgroup_reserved);
2083 trans->qgroup_reserved = 0;
2084 }
Simon Kirbyc2cf52e2013-03-19 22:41:23 +00002085 btrfs_warn(root->fs_info, "Skipping commit of aborted transaction.");
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002086 if (current->journal_info == trans)
2087 current->journal_info = NULL;
Josef Bacik7b8b92a2012-05-31 15:52:43 -04002088 cleanup_transaction(trans, root, ret);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01002089
2090 return ret;
Chris Mason79154b12007-03-22 15:59:16 -04002091}
2092
Chris Masond352ac62008-09-29 15:18:18 -04002093/*
David Sterba9d1a2a32013-03-12 15:13:28 +00002094 * return < 0 if error
2095 * 0 if there are no more dead_roots at the time of call
2096 * 1 there are more to be processed, call me again
2097 *
2098 * The return value indicates there are certainly more snapshots to delete, but
2099 * if there comes a new one during processing, it may return 0. We don't mind,
2100 * because btrfs_commit_super will poke cleaner thread and it will process it a
2101 * few seconds later.
Chris Masond352ac62008-09-29 15:18:18 -04002102 */
David Sterba9d1a2a32013-03-12 15:13:28 +00002103int btrfs_clean_one_deleted_snapshot(struct btrfs_root *root)
Chris Masone9d0b132007-08-10 14:06:19 -04002104{
David Sterba9d1a2a32013-03-12 15:13:28 +00002105 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002106 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Masone9d0b132007-08-10 14:06:19 -04002107
Josef Bacika4abeea2011-04-11 17:25:13 -04002108 spin_lock(&fs_info->trans_lock);
David Sterba9d1a2a32013-03-12 15:13:28 +00002109 if (list_empty(&fs_info->dead_roots)) {
2110 spin_unlock(&fs_info->trans_lock);
2111 return 0;
2112 }
2113 root = list_first_entry(&fs_info->dead_roots,
2114 struct btrfs_root, root_list);
Josef Bacikcfad3922013-07-25 15:11:47 -04002115 list_del_init(&root->root_list);
Josef Bacika4abeea2011-04-11 17:25:13 -04002116 spin_unlock(&fs_info->trans_lock);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002117
Frank Holtonefe120a2013-12-20 11:37:06 -05002118 pr_debug("BTRFS: cleaner removing %llu\n", root->objectid);
Jeff Mahoney2c536792011-10-03 23:22:41 -04002119
David Sterba9d1a2a32013-03-12 15:13:28 +00002120 btrfs_kill_all_delayed_nodes(root);
Yan, Zheng76dda932009-09-21 16:00:26 -04002121
David Sterba9d1a2a32013-03-12 15:13:28 +00002122 if (btrfs_header_backref_rev(root->node) <
2123 BTRFS_MIXED_BACKREF_REV)
2124 ret = btrfs_drop_snapshot(root, NULL, 0, 0);
2125 else
2126 ret = btrfs_drop_snapshot(root, NULL, 1, 0);
David Sterba32471dc2014-02-05 02:03:47 +01002127
Josef Bacik6596a9282013-07-31 10:28:05 -04002128 return (ret < 0) ? 0 : 1;
Chris Masone9d0b132007-08-10 14:06:19 -04002129}
David Sterba572d9ab2014-02-05 15:26:17 +01002130
2131void btrfs_apply_pending_changes(struct btrfs_fs_info *fs_info)
2132{
2133 unsigned long prev;
2134 unsigned long bit;
2135
Qu Wenruo6c9fe142015-01-20 17:05:33 +08002136 prev = xchg(&fs_info->pending_changes, 0);
David Sterba572d9ab2014-02-05 15:26:17 +01002137 if (!prev)
2138 return;
2139
David Sterba7e1876a2014-02-05 15:26:17 +01002140 bit = 1 << BTRFS_PENDING_SET_INODE_MAP_CACHE;
2141 if (prev & bit)
2142 btrfs_set_opt(fs_info->mount_opt, INODE_MAP_CACHE);
2143 prev &= ~bit;
2144
2145 bit = 1 << BTRFS_PENDING_CLEAR_INODE_MAP_CACHE;
2146 if (prev & bit)
2147 btrfs_clear_opt(fs_info->mount_opt, INODE_MAP_CACHE);
2148 prev &= ~bit;
2149
David Sterbad51033d2014-11-12 14:24:35 +01002150 bit = 1 << BTRFS_PENDING_COMMIT;
2151 if (prev & bit)
2152 btrfs_debug(fs_info, "pending commit done");
2153 prev &= ~bit;
2154
David Sterba572d9ab2014-02-05 15:26:17 +01002155 if (prev)
2156 btrfs_warn(fs_info,
2157 "unknown pending changes left 0x%lx, ignoring", prev);
2158}