blob: cb2dfe293947c228bbbcfcba4b37fb4b427102f6 [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>
Chris Mason79154b12007-03-22 15:59:16 -040025#include "ctree.h"
26#include "disk-io.h"
27#include "transaction.h"
Chris Mason925baed2008-06-25 16:01:30 -040028#include "locking.h"
Chris Masone02119d2008-09-05 16:13:11 -040029#include "tree-log.h"
Li Zefan581bb052011-04-20 10:06:11 +080030#include "inode-map.h"
Stefan Behrens733f4fb2012-05-25 16:06:10 +020031#include "volumes.h"
Chris Mason79154b12007-03-22 15:59:16 -040032
Chris Mason0f7d52f2007-04-09 10:42:37 -040033#define BTRFS_ROOT_TRANS_TAG 0
34
Jeff Mahoney49b25e02012-03-01 17:24:58 +010035void put_transaction(struct btrfs_transaction *transaction)
Chris Mason79154b12007-03-22 15:59:16 -040036{
Josef Bacik13c5a932011-04-11 15:45:29 -040037 WARN_ON(atomic_read(&transaction->use_count) == 0);
38 if (atomic_dec_and_test(&transaction->use_count)) {
Josef Bacika4abeea2011-04-11 17:25:13 -040039 BUG_ON(!list_empty(&transaction->list));
Arne Jansen00f04b82011-09-14 12:37:00 +020040 WARN_ON(transaction->delayed_refs.root.rb_node);
41 WARN_ON(!list_empty(&transaction->delayed_refs.seq_head));
Chris Mason2c90e5d2007-04-02 10:50:19 -040042 memset(transaction, 0, sizeof(*transaction));
43 kmem_cache_free(btrfs_transaction_cachep, transaction);
Chris Mason78fae272007-03-25 11:35:08 -040044 }
Chris Mason79154b12007-03-22 15:59:16 -040045}
46
Josef Bacik817d52f2009-07-13 21:29:25 -040047static noinline void switch_commit_root(struct btrfs_root *root)
48{
Josef Bacik817d52f2009-07-13 21:29:25 -040049 free_extent_buffer(root->commit_root);
50 root->commit_root = btrfs_root_node(root);
Josef Bacik817d52f2009-07-13 21:29:25 -040051}
52
Chris Masond352ac62008-09-29 15:18:18 -040053/*
54 * either allocate a new transaction or hop into the existing one
55 */
Josef Bacika4abeea2011-04-11 17:25:13 -040056static noinline int join_transaction(struct btrfs_root *root, int nofail)
Chris Mason79154b12007-03-22 15:59:16 -040057{
58 struct btrfs_transaction *cur_trans;
Jan Schmidt19ae4e82012-05-20 15:42:19 +020059 struct btrfs_fs_info *fs_info = root->fs_info;
Josef Bacika4abeea2011-04-11 17:25:13 -040060
Jan Schmidt19ae4e82012-05-20 15:42:19 +020061 spin_lock(&fs_info->trans_lock);
Chris Masond43317d2011-11-06 03:26:19 -050062loop:
Jeff Mahoney49b25e02012-03-01 17:24:58 +010063 /* The file system has been taken offline. No new transactions. */
Jan Schmidt19ae4e82012-05-20 15:42:19 +020064 if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
65 spin_unlock(&fs_info->trans_lock);
Jeff Mahoney49b25e02012-03-01 17:24:58 +010066 return -EROFS;
67 }
68
Jan Schmidt19ae4e82012-05-20 15:42:19 +020069 if (fs_info->trans_no_join) {
Josef Bacika4abeea2011-04-11 17:25:13 -040070 if (!nofail) {
Jan Schmidt19ae4e82012-05-20 15:42:19 +020071 spin_unlock(&fs_info->trans_lock);
Josef Bacika4abeea2011-04-11 17:25:13 -040072 return -EBUSY;
73 }
74 }
75
Jan Schmidt19ae4e82012-05-20 15:42:19 +020076 cur_trans = fs_info->running_transaction;
Josef Bacika4abeea2011-04-11 17:25:13 -040077 if (cur_trans) {
David Sterba871383b2012-04-02 18:31:37 +020078 if (cur_trans->aborted) {
Jan Schmidt19ae4e82012-05-20 15:42:19 +020079 spin_unlock(&fs_info->trans_lock);
Jeff Mahoney49b25e02012-03-01 17:24:58 +010080 return cur_trans->aborted;
David Sterba871383b2012-04-02 18:31:37 +020081 }
Josef Bacika4abeea2011-04-11 17:25:13 -040082 atomic_inc(&cur_trans->use_count);
Josef Bacik13c5a932011-04-11 15:45:29 -040083 atomic_inc(&cur_trans->num_writers);
Josef Bacik15ee9bc2007-08-10 16:22:09 -040084 cur_trans->num_joined++;
Jan Schmidt19ae4e82012-05-20 15:42:19 +020085 spin_unlock(&fs_info->trans_lock);
Josef Bacika4abeea2011-04-11 17:25:13 -040086 return 0;
Chris Mason79154b12007-03-22 15:59:16 -040087 }
Jan Schmidt19ae4e82012-05-20 15:42:19 +020088 spin_unlock(&fs_info->trans_lock);
Josef Bacika4abeea2011-04-11 17:25:13 -040089
90 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
91 if (!cur_trans)
92 return -ENOMEM;
Chris Masond43317d2011-11-06 03:26:19 -050093
Jan Schmidt19ae4e82012-05-20 15:42:19 +020094 spin_lock(&fs_info->trans_lock);
95 if (fs_info->running_transaction) {
Chris Masond43317d2011-11-06 03:26:19 -050096 /*
97 * someone started a transaction after we unlocked. Make sure
98 * to redo the trans_no_join checks above
99 */
Josef Bacika4abeea2011-04-11 17:25:13 -0400100 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200101 cur_trans = fs_info->running_transaction;
Chris Masond43317d2011-11-06 03:26:19 -0500102 goto loop;
Dan Carpentere4b50e12012-06-19 13:30:11 +0300103 } else if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
104 spin_unlock(&fs_info->trans_lock);
Josef Bacik7b8b92a2012-05-31 15:52:43 -0400105 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
106 return -EROFS;
Josef Bacika4abeea2011-04-11 17:25:13 -0400107 }
Chris Masond43317d2011-11-06 03:26:19 -0500108
Josef Bacika4abeea2011-04-11 17:25:13 -0400109 atomic_set(&cur_trans->num_writers, 1);
110 cur_trans->num_joined = 0;
111 init_waitqueue_head(&cur_trans->writer_wait);
112 init_waitqueue_head(&cur_trans->commit_wait);
113 cur_trans->in_commit = 0;
114 cur_trans->blocked = 0;
115 /*
116 * One for this trans handle, one so it will live on until we
117 * commit the transaction.
118 */
119 atomic_set(&cur_trans->use_count, 2);
120 cur_trans->commit_done = 0;
121 cur_trans->start_time = get_seconds();
122
123 cur_trans->delayed_refs.root = RB_ROOT;
124 cur_trans->delayed_refs.num_entries = 0;
125 cur_trans->delayed_refs.num_heads_ready = 0;
126 cur_trans->delayed_refs.num_heads = 0;
127 cur_trans->delayed_refs.flushing = 0;
128 cur_trans->delayed_refs.run_delayed_start = 0;
Arne Jansen00f04b82011-09-14 12:37:00 +0200129 cur_trans->delayed_refs.seq = 1;
Jan Schmidt20b297d2012-05-20 15:43:53 +0200130
131 /*
132 * although the tree mod log is per file system and not per transaction,
133 * the log must never go across transaction boundaries.
134 */
135 smp_mb();
136 if (!list_empty(&fs_info->tree_mod_seq_list)) {
137 printk(KERN_ERR "btrfs: tree_mod_seq_list not empty when "
138 "creating a fresh transaction\n");
139 WARN_ON(1);
140 }
141 if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) {
142 printk(KERN_ERR "btrfs: tree_mod_log rb tree not empty when "
143 "creating a fresh transaction\n");
144 WARN_ON(1);
145 }
146 atomic_set(&fs_info->tree_mod_seq, 0);
147
Jan Schmidta1686502011-12-12 16:10:07 +0100148 init_waitqueue_head(&cur_trans->delayed_refs.seq_wait);
Josef Bacika4abeea2011-04-11 17:25:13 -0400149 spin_lock_init(&cur_trans->commit_lock);
150 spin_lock_init(&cur_trans->delayed_refs.lock);
Arne Jansen00f04b82011-09-14 12:37:00 +0200151 INIT_LIST_HEAD(&cur_trans->delayed_refs.seq_head);
Josef Bacika4abeea2011-04-11 17:25:13 -0400152
153 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200154 list_add_tail(&cur_trans->list, &fs_info->trans_list);
Josef Bacika4abeea2011-04-11 17:25:13 -0400155 extent_io_tree_init(&cur_trans->dirty_pages,
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200156 fs_info->btree_inode->i_mapping);
157 fs_info->generation++;
158 cur_trans->transid = fs_info->generation;
159 fs_info->running_transaction = cur_trans;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100160 cur_trans->aborted = 0;
Jan Schmidt19ae4e82012-05-20 15:42:19 +0200161 spin_unlock(&fs_info->trans_lock);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400162
Chris Mason79154b12007-03-22 15:59:16 -0400163 return 0;
164}
165
Chris Masond352ac62008-09-29 15:18:18 -0400166/*
Chris Masond3977122009-01-05 21:25:51 -0500167 * this does all the record keeping required to make sure that a reference
168 * counted root is properly recorded in a given transaction. This is required
169 * to make sure the old root from before we joined the transaction is deleted
170 * when the transaction commits
Chris Masond352ac62008-09-29 15:18:18 -0400171 */
Chris Mason75857172011-06-13 20:00:16 -0400172static int record_root_in_trans(struct btrfs_trans_handle *trans,
Josef Bacika4abeea2011-04-11 17:25:13 -0400173 struct btrfs_root *root)
Chris Mason6702ed42007-08-07 16:15:09 -0400174{
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400175 if (root->ref_cows && root->last_trans < trans->transid) {
Chris Mason6702ed42007-08-07 16:15:09 -0400176 WARN_ON(root == root->fs_info->extent_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400177 WARN_ON(root->commit_root != root->node);
Yan Zheng31153d82008-07-28 15:32:19 -0400178
Chris Mason75857172011-06-13 20:00:16 -0400179 /*
180 * see below for in_trans_setup usage rules
181 * we have the reloc mutex held now, so there
182 * is only one writer in this function
183 */
184 root->in_trans_setup = 1;
185
186 /* make sure readers find in_trans_setup before
187 * they find our root->last_trans update
188 */
189 smp_wmb();
190
Josef Bacika4abeea2011-04-11 17:25:13 -0400191 spin_lock(&root->fs_info->fs_roots_radix_lock);
192 if (root->last_trans == trans->transid) {
193 spin_unlock(&root->fs_info->fs_roots_radix_lock);
194 return 0;
195 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400196 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
197 (unsigned long)root->root_key.objectid,
198 BTRFS_ROOT_TRANS_TAG);
Josef Bacika4abeea2011-04-11 17:25:13 -0400199 spin_unlock(&root->fs_info->fs_roots_radix_lock);
Chris Mason75857172011-06-13 20:00:16 -0400200 root->last_trans = trans->transid;
201
202 /* this is pretty tricky. We don't want to
203 * take the relocation lock in btrfs_record_root_in_trans
204 * unless we're really doing the first setup for this root in
205 * this transaction.
206 *
207 * Normally we'd use root->last_trans as a flag to decide
208 * if we want to take the expensive mutex.
209 *
210 * But, we have to set root->last_trans before we
211 * init the relocation root, otherwise, we trip over warnings
212 * in ctree.c. The solution used here is to flag ourselves
213 * with root->in_trans_setup. When this is 1, we're still
214 * fixing up the reloc trees and everyone must wait.
215 *
216 * When this is zero, they can trust root->last_trans and fly
217 * through btrfs_record_root_in_trans without having to take the
218 * lock. smp_wmb() makes sure that all the writes above are
219 * done before we pop in the zero below
220 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400221 btrfs_init_reloc_root(trans, root);
Chris Mason75857172011-06-13 20:00:16 -0400222 smp_wmb();
223 root->in_trans_setup = 0;
Chris Mason6702ed42007-08-07 16:15:09 -0400224 }
225 return 0;
226}
227
Chris Mason75857172011-06-13 20:00:16 -0400228
229int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
230 struct btrfs_root *root)
231{
232 if (!root->ref_cows)
233 return 0;
234
235 /*
236 * see record_root_in_trans for comments about in_trans_setup usage
237 * and barriers
238 */
239 smp_rmb();
240 if (root->last_trans == trans->transid &&
241 !root->in_trans_setup)
242 return 0;
243
244 mutex_lock(&root->fs_info->reloc_mutex);
245 record_root_in_trans(trans, root);
246 mutex_unlock(&root->fs_info->reloc_mutex);
247
248 return 0;
249}
250
Chris Masond352ac62008-09-29 15:18:18 -0400251/* wait for commit against the current transaction to become unblocked
252 * when this is done, it is safe to start a new transaction, but the current
253 * transaction might not be fully on disk.
254 */
Chris Mason37d1aee2008-07-31 10:48:37 -0400255static void wait_current_trans(struct btrfs_root *root)
Chris Mason79154b12007-03-22 15:59:16 -0400256{
Chris Masonf9295742008-07-17 12:54:14 -0400257 struct btrfs_transaction *cur_trans;
Chris Mason79154b12007-03-22 15:59:16 -0400258
Josef Bacika4abeea2011-04-11 17:25:13 -0400259 spin_lock(&root->fs_info->trans_lock);
Chris Masonf9295742008-07-17 12:54:14 -0400260 cur_trans = root->fs_info->running_transaction;
Chris Mason37d1aee2008-07-31 10:48:37 -0400261 if (cur_trans && cur_trans->blocked) {
Josef Bacik13c5a932011-04-11 15:45:29 -0400262 atomic_inc(&cur_trans->use_count);
Josef Bacika4abeea2011-04-11 17:25:13 -0400263 spin_unlock(&root->fs_info->trans_lock);
Li Zefan72d63ed2011-07-14 03:17:00 +0000264
265 wait_event(root->fs_info->transaction_wait,
266 !cur_trans->blocked);
Chris Masonf9295742008-07-17 12:54:14 -0400267 put_transaction(cur_trans);
Josef Bacika4abeea2011-04-11 17:25:13 -0400268 } else {
269 spin_unlock(&root->fs_info->trans_lock);
Chris Masonf9295742008-07-17 12:54:14 -0400270 }
Chris Mason37d1aee2008-07-31 10:48:37 -0400271}
272
Josef Bacik249ac1e2009-11-10 21:23:48 -0500273enum btrfs_trans_type {
274 TRANS_START,
275 TRANS_JOIN,
276 TRANS_USERSPACE,
Josef Bacik0af3d002010-06-21 14:48:16 -0400277 TRANS_JOIN_NOLOCK,
Josef Bacik249ac1e2009-11-10 21:23:48 -0500278};
279
Yan, Zhenga22285a2010-05-16 10:48:46 -0400280static int may_wait_transaction(struct btrfs_root *root, int type)
Chris Mason37d1aee2008-07-31 10:48:37 -0400281{
Josef Bacika4abeea2011-04-11 17:25:13 -0400282 if (root->fs_info->log_root_recovering)
283 return 0;
284
285 if (type == TRANS_USERSPACE)
Yan, Zhenga22285a2010-05-16 10:48:46 -0400286 return 1;
Josef Bacika4abeea2011-04-11 17:25:13 -0400287
288 if (type == TRANS_START &&
289 !atomic_read(&root->fs_info->open_ioctl_trans))
290 return 1;
291
Yan, Zhenga22285a2010-05-16 10:48:46 -0400292 return 0;
293}
294
295static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
296 u64 num_items, int type)
297{
298 struct btrfs_trans_handle *h;
299 struct btrfs_transaction *cur_trans;
Josef Bacikb5009942011-06-07 15:07:51 -0400300 u64 num_bytes = 0;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400301 int ret;
liuboacce9522011-01-06 19:30:25 +0800302
303 if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
304 return ERR_PTR(-EROFS);
Josef Bacik2a1eb462011-04-13 15:15:59 -0400305
306 if (current->journal_info) {
307 WARN_ON(type != TRANS_JOIN && type != TRANS_JOIN_NOLOCK);
308 h = current->journal_info;
309 h->use_count++;
310 h->orig_rsv = h->block_rsv;
311 h->block_rsv = NULL;
312 goto got_it;
313 }
Josef Bacikb5009942011-06-07 15:07:51 -0400314
315 /*
316 * Do the reservation before we join the transaction so we can do all
317 * the appropriate flushing if need be.
318 */
319 if (num_items > 0 && root != root->fs_info->chunk_root) {
320 num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
Josef Bacik4a92b1b2011-08-30 12:34:28 -0400321 ret = btrfs_block_rsv_add(root,
Josef Bacikb5009942011-06-07 15:07:51 -0400322 &root->fs_info->trans_block_rsv,
323 num_bytes);
324 if (ret)
325 return ERR_PTR(ret);
326 }
Yan, Zhenga22285a2010-05-16 10:48:46 -0400327again:
328 h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
329 if (!h)
330 return ERR_PTR(-ENOMEM);
331
Yan, Zhenga22285a2010-05-16 10:48:46 -0400332 if (may_wait_transaction(root, type))
Chris Mason37d1aee2008-07-31 10:48:37 -0400333 wait_current_trans(root);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400334
Josef Bacika4abeea2011-04-11 17:25:13 -0400335 do {
336 ret = join_transaction(root, type == TRANS_JOIN_NOLOCK);
337 if (ret == -EBUSY)
338 wait_current_trans(root);
339 } while (ret == -EBUSY);
340
Tsutomu Itohdb5b4932011-03-23 08:14:16 +0000341 if (ret < 0) {
Yoshinori Sano6e8df2a2011-04-03 12:31:28 +0000342 kmem_cache_free(btrfs_trans_handle_cachep, h);
Tsutomu Itohdb5b4932011-03-23 08:14:16 +0000343 return ERR_PTR(ret);
344 }
Chris Mason0f7d52f2007-04-09 10:42:37 -0400345
Yan, Zhenga22285a2010-05-16 10:48:46 -0400346 cur_trans = root->fs_info->running_transaction;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400347
348 h->transid = cur_trans->transid;
349 h->transaction = cur_trans;
Chris Mason79154b12007-03-22 15:59:16 -0400350 h->blocks_used = 0;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400351 h->bytes_reserved = 0;
Chris Mason56bec292009-03-13 10:10:06 -0400352 h->delayed_ref_updates = 0;
Josef Bacik2a1eb462011-04-13 15:15:59 -0400353 h->use_count = 1;
Yan, Zhengf0486c62010-05-16 10:46:25 -0400354 h->block_rsv = NULL;
Josef Bacik2a1eb462011-04-13 15:15:59 -0400355 h->orig_rsv = NULL;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100356 h->aborted = 0;
Chris Masonb7ec40d2009-03-12 20:12:45 -0400357
Yan, Zhenga22285a2010-05-16 10:48:46 -0400358 smp_mb();
359 if (cur_trans->blocked && may_wait_transaction(root, type)) {
360 btrfs_commit_transaction(h, root);
361 goto again;
362 }
Josef Bacik9ed74f22009-09-11 16:12:44 -0400363
Josef Bacikb5009942011-06-07 15:07:51 -0400364 if (num_bytes) {
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500365 trace_btrfs_space_reservation(root->fs_info, "transaction",
Liu Bo2bcc0322012-03-29 09:57:44 -0400366 h->transid, num_bytes, 1);
Josef Bacikb5009942011-06-07 15:07:51 -0400367 h->block_rsv = &root->fs_info->trans_block_rsv;
368 h->bytes_reserved = num_bytes;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400369 }
370
Josef Bacik2a1eb462011-04-13 15:15:59 -0400371got_it:
Josef Bacika4abeea2011-04-11 17:25:13 -0400372 btrfs_record_root_in_trans(h, root);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400373
374 if (!current->journal_info && type != TRANS_USERSPACE)
375 current->journal_info = h;
Chris Mason79154b12007-03-22 15:59:16 -0400376 return h;
377}
378
Chris Masonf9295742008-07-17 12:54:14 -0400379struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
Yan, Zhenga22285a2010-05-16 10:48:46 -0400380 int num_items)
Chris Masonf9295742008-07-17 12:54:14 -0400381{
Yan, Zhenga22285a2010-05-16 10:48:46 -0400382 return start_transaction(root, num_items, TRANS_START);
Chris Masonf9295742008-07-17 12:54:14 -0400383}
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400384struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
Chris Masonf9295742008-07-17 12:54:14 -0400385{
Yan, Zhenga22285a2010-05-16 10:48:46 -0400386 return start_transaction(root, 0, TRANS_JOIN);
Chris Masonf9295742008-07-17 12:54:14 -0400387}
388
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400389struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
Josef Bacik0af3d002010-06-21 14:48:16 -0400390{
391 return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
392}
393
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400394struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
Sage Weil9ca9ee02008-08-04 10:41:27 -0400395{
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400396 return start_transaction(root, 0, TRANS_USERSPACE);
Sage Weil9ca9ee02008-08-04 10:41:27 -0400397}
398
Chris Masond352ac62008-09-29 15:18:18 -0400399/* wait for a transaction commit to be fully complete */
Li Zefanb9c83002011-07-14 03:17:14 +0000400static noinline void wait_for_commit(struct btrfs_root *root,
Chris Mason89ce8a62008-06-25 16:01:31 -0400401 struct btrfs_transaction *commit)
402{
Li Zefan72d63ed2011-07-14 03:17:00 +0000403 wait_event(commit->commit_wait, commit->commit_done);
Chris Mason89ce8a62008-06-25 16:01:31 -0400404}
405
Sage Weil46204592010-10-29 15:41:32 -0400406int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
407{
408 struct btrfs_transaction *cur_trans = NULL, *t;
409 int ret;
410
Sage Weil46204592010-10-29 15:41:32 -0400411 ret = 0;
412 if (transid) {
413 if (transid <= root->fs_info->last_trans_committed)
Josef Bacika4abeea2011-04-11 17:25:13 -0400414 goto out;
Sage Weil46204592010-10-29 15:41:32 -0400415
416 /* find specified transaction */
Josef Bacika4abeea2011-04-11 17:25:13 -0400417 spin_lock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400418 list_for_each_entry(t, &root->fs_info->trans_list, list) {
419 if (t->transid == transid) {
420 cur_trans = t;
Josef Bacika4abeea2011-04-11 17:25:13 -0400421 atomic_inc(&cur_trans->use_count);
Sage Weil46204592010-10-29 15:41:32 -0400422 break;
423 }
424 if (t->transid > transid)
425 break;
426 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400427 spin_unlock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400428 ret = -EINVAL;
429 if (!cur_trans)
Josef Bacika4abeea2011-04-11 17:25:13 -0400430 goto out; /* bad transid */
Sage Weil46204592010-10-29 15:41:32 -0400431 } else {
432 /* find newest transaction that is committing | committed */
Josef Bacika4abeea2011-04-11 17:25:13 -0400433 spin_lock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400434 list_for_each_entry_reverse(t, &root->fs_info->trans_list,
435 list) {
436 if (t->in_commit) {
437 if (t->commit_done)
Josef Bacik3473f3c2011-06-09 10:15:17 -0400438 break;
Sage Weil46204592010-10-29 15:41:32 -0400439 cur_trans = t;
Josef Bacika4abeea2011-04-11 17:25:13 -0400440 atomic_inc(&cur_trans->use_count);
Sage Weil46204592010-10-29 15:41:32 -0400441 break;
442 }
443 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400444 spin_unlock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400445 if (!cur_trans)
Josef Bacika4abeea2011-04-11 17:25:13 -0400446 goto out; /* nothing committing|committed */
Sage Weil46204592010-10-29 15:41:32 -0400447 }
448
Sage Weil46204592010-10-29 15:41:32 -0400449 wait_for_commit(root, cur_trans);
450
Sage Weil46204592010-10-29 15:41:32 -0400451 put_transaction(cur_trans);
452 ret = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -0400453out:
Sage Weil46204592010-10-29 15:41:32 -0400454 return ret;
455}
456
Chris Mason37d1aee2008-07-31 10:48:37 -0400457void btrfs_throttle(struct btrfs_root *root)
458{
Josef Bacika4abeea2011-04-11 17:25:13 -0400459 if (!atomic_read(&root->fs_info->open_ioctl_trans))
Sage Weil9ca9ee02008-08-04 10:41:27 -0400460 wait_current_trans(root);
Chris Mason37d1aee2008-07-31 10:48:37 -0400461}
462
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400463static int should_end_transaction(struct btrfs_trans_handle *trans,
464 struct btrfs_root *root)
465{
466 int ret;
Josef Bacik36ba0222011-10-18 12:15:48 -0400467
468 ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400469 return ret ? 1 : 0;
470}
471
472int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
473 struct btrfs_root *root)
474{
475 struct btrfs_transaction *cur_trans = trans->transaction;
Josef Bacik9c8d86d2011-09-19 11:58:54 -0400476 struct btrfs_block_rsv *rsv = trans->block_rsv;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400477 int updates;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100478 int err;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400479
Josef Bacika4abeea2011-04-11 17:25:13 -0400480 smp_mb();
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400481 if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
482 return 1;
483
Josef Bacik9c8d86d2011-09-19 11:58:54 -0400484 /*
485 * We need to do this in case we're deleting csums so the global block
486 * rsv get's used instead of the csum block rsv.
487 */
488 trans->block_rsv = NULL;
489
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400490 updates = trans->delayed_ref_updates;
491 trans->delayed_ref_updates = 0;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100492 if (updates) {
493 err = btrfs_run_delayed_refs(trans, root, updates);
494 if (err) /* Error code will also eval true */
495 return err;
496 }
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400497
Josef Bacik9c8d86d2011-09-19 11:58:54 -0400498 trans->block_rsv = rsv;
499
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400500 return should_end_transaction(trans, root);
501}
502
Chris Mason89ce8a62008-06-25 16:01:31 -0400503static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
Josef Bacik0af3d002010-06-21 14:48:16 -0400504 struct btrfs_root *root, int throttle, int lock)
Chris Mason79154b12007-03-22 15:59:16 -0400505{
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400506 struct btrfs_transaction *cur_trans = trans->transaction;
Chris Masonab78c842008-07-29 16:15:18 -0400507 struct btrfs_fs_info *info = root->fs_info;
Chris Masonc3e69d52009-03-13 10:17:05 -0400508 int count = 0;
Dave Jones4edc2ca2012-04-12 16:03:56 -0400509 int err = 0;
Chris Masond6e4a422007-04-06 15:37:36 -0400510
Josef Bacik2a1eb462011-04-13 15:15:59 -0400511 if (--trans->use_count) {
512 trans->block_rsv = trans->orig_rsv;
513 return 0;
514 }
515
Josef Bacikb24e03d2011-10-14 14:40:17 -0400516 btrfs_trans_release_metadata(trans, root);
Josef Bacik4c13d752011-08-30 11:31:29 -0400517 trans->block_rsv = NULL;
Chris Mason203bf282012-01-06 15:23:57 -0500518 while (count < 2) {
Chris Masonc3e69d52009-03-13 10:17:05 -0400519 unsigned long cur = trans->delayed_ref_updates;
520 trans->delayed_ref_updates = 0;
521 if (cur &&
522 trans->transaction->delayed_refs.num_heads_ready > 64) {
523 trans->delayed_ref_updates = 0;
524 btrfs_run_delayed_refs(trans, root, cur);
525 } else {
526 break;
527 }
528 count++;
Chris Mason56bec292009-03-13 10:10:06 -0400529 }
530
Josef Bacika4abeea2011-04-11 17:25:13 -0400531 if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
532 should_end_transaction(trans, root)) {
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400533 trans->transaction->blocked = 1;
Josef Bacika4abeea2011-04-11 17:25:13 -0400534 smp_wmb();
535 }
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400536
Josef Bacik0af3d002010-06-21 14:48:16 -0400537 if (lock && cur_trans->blocked && !cur_trans->in_commit) {
Josef Bacik81317fd2011-07-24 15:45:34 -0400538 if (throttle) {
539 /*
540 * We may race with somebody else here so end up having
541 * to call end_transaction on ourselves again, so inc
542 * our use_count.
543 */
544 trans->use_count++;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400545 return btrfs_commit_transaction(trans, root);
Josef Bacik81317fd2011-07-24 15:45:34 -0400546 } else {
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400547 wake_up_process(info->transaction_kthread);
Josef Bacik81317fd2011-07-24 15:45:34 -0400548 }
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400549 }
550
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400551 WARN_ON(cur_trans != info->running_transaction);
Josef Bacik13c5a932011-04-11 15:45:29 -0400552 WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
553 atomic_dec(&cur_trans->num_writers);
Chris Mason89ce8a62008-06-25 16:01:31 -0400554
Sage Weil99d16cb2010-10-29 15:37:34 -0400555 smp_mb();
Chris Mason79154b12007-03-22 15:59:16 -0400556 if (waitqueue_active(&cur_trans->writer_wait))
557 wake_up(&cur_trans->writer_wait);
Chris Mason79154b12007-03-22 15:59:16 -0400558 put_transaction(cur_trans);
Josef Bacik9ed74f22009-09-11 16:12:44 -0400559
560 if (current->journal_info == trans)
561 current->journal_info = NULL;
Chris Masonab78c842008-07-29 16:15:18 -0400562
Yan, Zheng24bbcf02009-11-12 09:36:34 +0000563 if (throttle)
564 btrfs_run_delayed_iputs(root);
565
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100566 if (trans->aborted ||
567 root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
Dave Jones4edc2ca2012-04-12 16:03:56 -0400568 err = -EIO;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100569 }
570
Dave Jones4edc2ca2012-04-12 16:03:56 -0400571 memset(trans, 0, sizeof(*trans));
572 kmem_cache_free(btrfs_trans_handle_cachep, trans);
573 return err;
Chris Mason79154b12007-03-22 15:59:16 -0400574}
575
Chris Mason89ce8a62008-06-25 16:01:31 -0400576int btrfs_end_transaction(struct btrfs_trans_handle *trans,
577 struct btrfs_root *root)
578{
Miao Xie16cdcec2011-04-22 18:12:22 +0800579 int ret;
580
581 ret = __btrfs_end_transaction(trans, root, 0, 1);
582 if (ret)
583 return ret;
584 return 0;
Chris Mason89ce8a62008-06-25 16:01:31 -0400585}
586
587int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
588 struct btrfs_root *root)
589{
Miao Xie16cdcec2011-04-22 18:12:22 +0800590 int ret;
591
592 ret = __btrfs_end_transaction(trans, root, 1, 1);
593 if (ret)
594 return ret;
595 return 0;
Josef Bacik0af3d002010-06-21 14:48:16 -0400596}
597
598int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
599 struct btrfs_root *root)
600{
Miao Xie16cdcec2011-04-22 18:12:22 +0800601 int ret;
602
603 ret = __btrfs_end_transaction(trans, root, 0, 0);
604 if (ret)
605 return ret;
606 return 0;
607}
608
609int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans,
610 struct btrfs_root *root)
611{
612 return __btrfs_end_transaction(trans, root, 1, 1);
Chris Mason89ce8a62008-06-25 16:01:31 -0400613}
614
Chris Masond352ac62008-09-29 15:18:18 -0400615/*
616 * when btree blocks are allocated, they have some corresponding bits set for
617 * them in one of two extent_io trees. This is used to make sure all of
Chris Mason690587d2009-10-13 13:29:19 -0400618 * those extents are sent to disk but does not wait on them
Chris Masond352ac62008-09-29 15:18:18 -0400619 */
Chris Mason690587d2009-10-13 13:29:19 -0400620int btrfs_write_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000621 struct extent_io_tree *dirty_pages, int mark)
Chris Mason79154b12007-03-22 15:59:16 -0400622{
Chris Mason777e6bd2008-08-15 15:34:15 -0400623 int err = 0;
Chris Mason7c4452b2007-04-28 09:29:35 -0400624 int werr = 0;
Josef Bacik17283662011-09-26 13:58:47 -0400625 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
Chris Mason777e6bd2008-08-15 15:34:15 -0400626 u64 start = 0;
Chris Mason5f39d392007-10-15 16:14:19 -0400627 u64 end;
Chris Mason7c4452b2007-04-28 09:29:35 -0400628
Josef Bacik17283662011-09-26 13:58:47 -0400629 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
630 mark)) {
631 convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT, mark,
632 GFP_NOFS);
633 err = filemap_fdatawrite_range(mapping, start, end);
634 if (err)
635 werr = err;
636 cond_resched();
637 start = end + 1;
Chris Mason7c4452b2007-04-28 09:29:35 -0400638 }
Chris Mason690587d2009-10-13 13:29:19 -0400639 if (err)
640 werr = err;
641 return werr;
642}
643
644/*
645 * when btree blocks are allocated, they have some corresponding bits set for
646 * them in one of two extent_io trees. This is used to make sure all of
647 * those extents are on disk for transaction or log commit. We wait
648 * on all the pages and clear them from the dirty pages state tree
649 */
650int btrfs_wait_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000651 struct extent_io_tree *dirty_pages, int mark)
Chris Mason690587d2009-10-13 13:29:19 -0400652{
Chris Mason690587d2009-10-13 13:29:19 -0400653 int err = 0;
654 int werr = 0;
Josef Bacik17283662011-09-26 13:58:47 -0400655 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
Chris Mason690587d2009-10-13 13:29:19 -0400656 u64 start = 0;
657 u64 end;
Chris Mason690587d2009-10-13 13:29:19 -0400658
Josef Bacik17283662011-09-26 13:58:47 -0400659 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
660 EXTENT_NEED_WAIT)) {
661 clear_extent_bits(dirty_pages, start, end, EXTENT_NEED_WAIT, GFP_NOFS);
662 err = filemap_fdatawait_range(mapping, start, end);
663 if (err)
664 werr = err;
665 cond_resched();
666 start = end + 1;
Chris Mason777e6bd2008-08-15 15:34:15 -0400667 }
Chris Mason7c4452b2007-04-28 09:29:35 -0400668 if (err)
669 werr = err;
670 return werr;
Chris Mason79154b12007-03-22 15:59:16 -0400671}
672
Chris Mason690587d2009-10-13 13:29:19 -0400673/*
674 * when btree blocks are allocated, they have some corresponding bits set for
675 * them in one of two extent_io trees. This is used to make sure all of
676 * those extents are on disk for transaction or log commit
677 */
678int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000679 struct extent_io_tree *dirty_pages, int mark)
Chris Mason690587d2009-10-13 13:29:19 -0400680{
681 int ret;
682 int ret2;
683
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000684 ret = btrfs_write_marked_extents(root, dirty_pages, mark);
685 ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
Chris Masonbf0da8c2011-11-04 12:29:37 -0400686
687 if (ret)
688 return ret;
689 if (ret2)
690 return ret2;
691 return 0;
Chris Mason690587d2009-10-13 13:29:19 -0400692}
693
Chris Masond0c803c2008-09-11 16:17:57 -0400694int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
695 struct btrfs_root *root)
696{
697 if (!trans || !trans->transaction) {
698 struct inode *btree_inode;
699 btree_inode = root->fs_info->btree_inode;
700 return filemap_write_and_wait(btree_inode->i_mapping);
701 }
702 return btrfs_write_and_wait_marked_extents(root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000703 &trans->transaction->dirty_pages,
704 EXTENT_DIRTY);
Chris Masond0c803c2008-09-11 16:17:57 -0400705}
706
Chris Masond352ac62008-09-29 15:18:18 -0400707/*
708 * this is used to update the root pointer in the tree of tree roots.
709 *
710 * But, in the case of the extent allocation tree, updating the root
711 * pointer may allocate blocks which may change the root of the extent
712 * allocation tree.
713 *
714 * So, this loops and repeats and makes sure the cowonly root didn't
715 * change while the root pointer was being updated in the metadata.
716 */
Chris Mason0b86a832008-03-24 15:01:56 -0400717static int update_cowonly_root(struct btrfs_trans_handle *trans,
718 struct btrfs_root *root)
719{
720 int ret;
721 u64 old_root_bytenr;
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000722 u64 old_root_used;
Chris Mason0b86a832008-03-24 15:01:56 -0400723 struct btrfs_root *tree_root = root->fs_info->tree_root;
724
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000725 old_root_used = btrfs_root_used(&root->root_item);
Chris Mason0b86a832008-03-24 15:01:56 -0400726 btrfs_write_dirty_block_groups(trans, root);
Chris Mason56bec292009-03-13 10:10:06 -0400727
Chris Masond3977122009-01-05 21:25:51 -0500728 while (1) {
Chris Mason0b86a832008-03-24 15:01:56 -0400729 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000730 if (old_root_bytenr == root->node->start &&
731 old_root_used == btrfs_root_used(&root->root_item))
Chris Mason0b86a832008-03-24 15:01:56 -0400732 break;
Chris Mason87ef2bb2008-10-30 11:23:27 -0400733
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400734 btrfs_set_root_node(&root->root_item, root->node);
Chris Mason0b86a832008-03-24 15:01:56 -0400735 ret = btrfs_update_root(trans, tree_root,
736 &root->root_key,
737 &root->root_item);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100738 if (ret)
739 return ret;
Chris Mason56bec292009-03-13 10:10:06 -0400740
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000741 old_root_used = btrfs_root_used(&root->root_item);
Yan Zheng4a8c9a62009-07-22 10:07:05 -0400742 ret = btrfs_write_dirty_block_groups(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100743 if (ret)
744 return ret;
Chris Mason0b86a832008-03-24 15:01:56 -0400745 }
Yan Zheng276e6802009-07-30 09:40:40 -0400746
747 if (root != root->fs_info->extent_root)
748 switch_commit_root(root);
749
Chris Mason0b86a832008-03-24 15:01:56 -0400750 return 0;
751}
752
Chris Masond352ac62008-09-29 15:18:18 -0400753/*
754 * update all the cowonly tree roots on disk
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100755 *
756 * The error handling in this function may not be obvious. Any of the
757 * failures will cause the file system to go offline. We still need
758 * to clean up the delayed refs.
Chris Masond352ac62008-09-29 15:18:18 -0400759 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400760static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
761 struct btrfs_root *root)
Chris Mason79154b12007-03-22 15:59:16 -0400762{
Chris Mason79154b12007-03-22 15:59:16 -0400763 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Mason0b86a832008-03-24 15:01:56 -0400764 struct list_head *next;
Yan Zheng84234f32008-10-29 14:49:05 -0400765 struct extent_buffer *eb;
Chris Mason56bec292009-03-13 10:10:06 -0400766 int ret;
Yan Zheng84234f32008-10-29 14:49:05 -0400767
Chris Mason56bec292009-03-13 10:10:06 -0400768 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100769 if (ret)
770 return ret;
Chris Mason87ef2bb2008-10-30 11:23:27 -0400771
Yan Zheng84234f32008-10-29 14:49:05 -0400772 eb = btrfs_lock_root_node(fs_info->tree_root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100773 ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,
774 0, &eb);
Yan Zheng84234f32008-10-29 14:49:05 -0400775 btrfs_tree_unlock(eb);
776 free_extent_buffer(eb);
Chris Mason79154b12007-03-22 15:59:16 -0400777
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100778 if (ret)
779 return ret;
780
Chris Mason56bec292009-03-13 10:10:06 -0400781 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100782 if (ret)
783 return ret;
Chris Mason87ef2bb2008-10-30 11:23:27 -0400784
Stefan Behrens733f4fb2012-05-25 16:06:10 +0200785 ret = btrfs_run_dev_stats(trans, root->fs_info);
786 BUG_ON(ret);
787
Chris Masond3977122009-01-05 21:25:51 -0500788 while (!list_empty(&fs_info->dirty_cowonly_roots)) {
Chris Mason0b86a832008-03-24 15:01:56 -0400789 next = fs_info->dirty_cowonly_roots.next;
790 list_del_init(next);
791 root = list_entry(next, struct btrfs_root, dirty_list);
Chris Mason87ef2bb2008-10-30 11:23:27 -0400792
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100793 ret = update_cowonly_root(trans, root);
794 if (ret)
795 return ret;
Chris Mason79154b12007-03-22 15:59:16 -0400796 }
Yan Zheng276e6802009-07-30 09:40:40 -0400797
798 down_write(&fs_info->extent_commit_sem);
799 switch_commit_root(fs_info->extent_root);
800 up_write(&fs_info->extent_commit_sem);
801
Chris Mason79154b12007-03-22 15:59:16 -0400802 return 0;
803}
804
Chris Masond352ac62008-09-29 15:18:18 -0400805/*
806 * dead roots are old snapshots that need to be deleted. This allocates
807 * a dirty root struct and adds it into the list of dead roots that need to
808 * be deleted
809 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400810int btrfs_add_dead_root(struct btrfs_root *root)
Chris Mason5eda7b52007-06-22 14:16:25 -0400811{
Josef Bacika4abeea2011-04-11 17:25:13 -0400812 spin_lock(&root->fs_info->trans_lock);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400813 list_add(&root->root_list, &root->fs_info->dead_roots);
Josef Bacika4abeea2011-04-11 17:25:13 -0400814 spin_unlock(&root->fs_info->trans_lock);
Chris Mason5eda7b52007-06-22 14:16:25 -0400815 return 0;
816}
817
Chris Masond352ac62008-09-29 15:18:18 -0400818/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400819 * update all the cowonly tree roots on disk
Chris Masond352ac62008-09-29 15:18:18 -0400820 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400821static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
822 struct btrfs_root *root)
Chris Mason0f7d52f2007-04-09 10:42:37 -0400823{
Chris Mason0f7d52f2007-04-09 10:42:37 -0400824 struct btrfs_root *gang[8];
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400825 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400826 int i;
827 int ret;
Chris Mason54aa1f42007-06-22 14:16:25 -0400828 int err = 0;
829
Josef Bacika4abeea2011-04-11 17:25:13 -0400830 spin_lock(&fs_info->fs_roots_radix_lock);
Chris Masond3977122009-01-05 21:25:51 -0500831 while (1) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400832 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
833 (void **)gang, 0,
Chris Mason0f7d52f2007-04-09 10:42:37 -0400834 ARRAY_SIZE(gang),
835 BTRFS_ROOT_TRANS_TAG);
836 if (ret == 0)
837 break;
838 for (i = 0; i < ret; i++) {
839 root = gang[i];
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400840 radix_tree_tag_clear(&fs_info->fs_roots_radix,
841 (unsigned long)root->root_key.objectid,
842 BTRFS_ROOT_TRANS_TAG);
Josef Bacika4abeea2011-04-11 17:25:13 -0400843 spin_unlock(&fs_info->fs_roots_radix_lock);
Yan Zheng31153d82008-07-28 15:32:19 -0400844
Chris Masone02119d2008-09-05 16:13:11 -0400845 btrfs_free_log(trans, root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400846 btrfs_update_reloc_root(trans, root);
Yan, Zhengd68fc572010-05-16 10:49:58 -0400847 btrfs_orphan_commit_root(trans, root);
Chris Masone02119d2008-09-05 16:13:11 -0400848
Li Zefan82d59022011-04-20 10:33:24 +0800849 btrfs_save_ino_cache(root, trans);
850
Liu Bof1ebcc72011-11-14 20:48:06 -0500851 /* see comments in should_cow_block() */
852 root->force_cow = 0;
853 smp_wmb();
854
Yan Zheng978d9102009-06-15 20:01:02 -0400855 if (root->commit_root != root->node) {
Li Zefan581bb052011-04-20 10:06:11 +0800856 mutex_lock(&root->fs_commit_mutex);
Josef Bacik817d52f2009-07-13 21:29:25 -0400857 switch_commit_root(root);
Li Zefan581bb052011-04-20 10:06:11 +0800858 btrfs_unpin_free_ino(root);
859 mutex_unlock(&root->fs_commit_mutex);
860
Yan Zheng978d9102009-06-15 20:01:02 -0400861 btrfs_set_root_node(&root->root_item,
862 root->node);
863 }
Chris Mason9f3a7422007-08-07 15:52:19 -0400864
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400865 err = btrfs_update_root(trans, fs_info->tree_root,
Chris Mason0f7d52f2007-04-09 10:42:37 -0400866 &root->root_key,
867 &root->root_item);
Josef Bacika4abeea2011-04-11 17:25:13 -0400868 spin_lock(&fs_info->fs_roots_radix_lock);
Chris Mason54aa1f42007-06-22 14:16:25 -0400869 if (err)
870 break;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400871 }
872 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400873 spin_unlock(&fs_info->fs_roots_radix_lock);
Chris Mason54aa1f42007-06-22 14:16:25 -0400874 return err;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400875}
876
Chris Masond352ac62008-09-29 15:18:18 -0400877/*
878 * defrag a given btree. If cacheonly == 1, this won't read from the disk,
879 * otherwise every leaf in the btree is read and defragged.
880 */
Chris Masone9d0b132007-08-10 14:06:19 -0400881int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
882{
883 struct btrfs_fs_info *info = root->fs_info;
Chris Masone9d0b132007-08-10 14:06:19 -0400884 struct btrfs_trans_handle *trans;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400885 int ret;
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400886 unsigned long nr;
Chris Masone9d0b132007-08-10 14:06:19 -0400887
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400888 if (xchg(&root->defrag_running, 1))
Chris Masone9d0b132007-08-10 14:06:19 -0400889 return 0;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400890
Chris Mason6b800532007-10-15 16:17:34 -0400891 while (1) {
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400892 trans = btrfs_start_transaction(root, 0);
893 if (IS_ERR(trans))
894 return PTR_ERR(trans);
895
Chris Masone9d0b132007-08-10 14:06:19 -0400896 ret = btrfs_defrag_leaves(trans, root, cacheonly);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400897
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400898 nr = trans->blocks_used;
Chris Masone9d0b132007-08-10 14:06:19 -0400899 btrfs_end_transaction(trans, root);
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400900 btrfs_btree_balance_dirty(info->tree_root, nr);
Chris Masone9d0b132007-08-10 14:06:19 -0400901 cond_resched();
902
David Sterba7841cb22011-05-31 18:07:27 +0200903 if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
Chris Masone9d0b132007-08-10 14:06:19 -0400904 break;
905 }
906 root->defrag_running = 0;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400907 return ret;
Chris Masone9d0b132007-08-10 14:06:19 -0400908}
909
Chris Masond352ac62008-09-29 15:18:18 -0400910/*
911 * new snapshots need to be created at a very specific time in the
912 * transaction commit. This does the actual creation
913 */
Chris Mason80b67942008-02-01 16:35:04 -0500914static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
Chris Mason3063d292008-01-08 15:46:30 -0500915 struct btrfs_fs_info *fs_info,
916 struct btrfs_pending_snapshot *pending)
917{
918 struct btrfs_key key;
Chris Mason80b67942008-02-01 16:35:04 -0500919 struct btrfs_root_item *new_root_item;
Chris Mason3063d292008-01-08 15:46:30 -0500920 struct btrfs_root *tree_root = fs_info->tree_root;
921 struct btrfs_root *root = pending->root;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000922 struct btrfs_root *parent_root;
Liu Bo98c99422011-09-11 10:52:24 -0400923 struct btrfs_block_rsv *rsv;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000924 struct inode *parent_inode;
Josef Bacik6a912212010-11-20 09:48:00 +0000925 struct dentry *parent;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400926 struct dentry *dentry;
Chris Mason3063d292008-01-08 15:46:30 -0500927 struct extent_buffer *tmp;
Chris Mason925baed2008-06-25 16:01:30 -0400928 struct extent_buffer *old;
Chris Mason3063d292008-01-08 15:46:30 -0500929 int ret;
Yan, Zhengd68fc572010-05-16 10:49:58 -0400930 u64 to_reserve = 0;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000931 u64 index = 0;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400932 u64 objectid;
Li Zefanb83cc962010-12-20 16:04:08 +0800933 u64 root_flags;
Chris Mason3063d292008-01-08 15:46:30 -0500934
Liu Bo98c99422011-09-11 10:52:24 -0400935 rsv = trans->block_rsv;
936
Chris Mason80b67942008-02-01 16:35:04 -0500937 new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
938 if (!new_root_item) {
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100939 ret = pending->error = -ENOMEM;
Chris Mason80b67942008-02-01 16:35:04 -0500940 goto fail;
941 }
Yan, Zhenga22285a2010-05-16 10:48:46 -0400942
Li Zefan581bb052011-04-20 10:06:11 +0800943 ret = btrfs_find_free_objectid(tree_root, &objectid);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400944 if (ret) {
945 pending->error = ret;
Chris Mason3063d292008-01-08 15:46:30 -0500946 goto fail;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400947 }
Chris Mason3063d292008-01-08 15:46:30 -0500948
Yan, Zheng3fd0a552010-05-16 10:49:59 -0400949 btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
Yan, Zhengd68fc572010-05-16 10:49:58 -0400950
951 if (to_reserve > 0) {
Miao Xie62f30c52011-11-10 20:45:05 -0500952 ret = btrfs_block_rsv_add_noflush(root, &pending->block_rsv,
953 to_reserve);
Yan, Zhengd68fc572010-05-16 10:49:58 -0400954 if (ret) {
955 pending->error = ret;
956 goto fail;
957 }
958 }
959
Chris Mason3063d292008-01-08 15:46:30 -0500960 key.objectid = objectid;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400961 key.offset = (u64)-1;
962 key.type = BTRFS_ROOT_ITEM_KEY;
Chris Mason3063d292008-01-08 15:46:30 -0500963
Yan, Zhenga22285a2010-05-16 10:48:46 -0400964 trans->block_rsv = &pending->block_rsv;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000965
Yan, Zhenga22285a2010-05-16 10:48:46 -0400966 dentry = pending->dentry;
Josef Bacik6a912212010-11-20 09:48:00 +0000967 parent = dget_parent(dentry);
968 parent_inode = parent->d_inode;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400969 parent_root = BTRFS_I(parent_inode)->root;
Chris Mason75857172011-06-13 20:00:16 -0400970 record_root_in_trans(trans, parent_root);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400971
Sage Weil6bdb72d2010-03-15 17:27:13 +0000972 /*
973 * insert the directory item
974 */
Sage Weil6bdb72d2010-03-15 17:27:13 +0000975 ret = btrfs_set_inode_index(parent_inode, &index);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100976 BUG_ON(ret); /* -ENOMEM */
Sage Weil6bdb72d2010-03-15 17:27:13 +0000977 ret = btrfs_insert_dir_item(trans, parent_root,
Yan, Zhenga22285a2010-05-16 10:48:46 -0400978 dentry->d_name.name, dentry->d_name.len,
Miao Xie16cdcec2011-04-22 18:12:22 +0800979 parent_inode, &key,
Yan, Zhenga22285a2010-05-16 10:48:46 -0400980 BTRFS_FT_DIR, index);
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100981 if (ret == -EEXIST) {
Chris Masonfe66a052012-02-20 08:40:56 -0500982 pending->error = -EEXIST;
983 dput(parent);
984 goto fail;
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100985 } else if (ret) {
986 goto abort_trans_dput;
987 }
Sage Weil6bdb72d2010-03-15 17:27:13 +0000988
Yan, Zhenga22285a2010-05-16 10:48:46 -0400989 btrfs_i_size_write(parent_inode, parent_inode->i_size +
990 dentry->d_name.len * 2);
Sage Weil6bdb72d2010-03-15 17:27:13 +0000991 ret = btrfs_update_inode(trans, parent_root, parent_inode);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100992 if (ret)
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100993 goto abort_trans_dput;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000994
Chris Masone9993762011-06-17 16:14:09 -0400995 /*
996 * pull in the delayed directory update
997 * and the delayed inode item
998 * otherwise we corrupt the FS during
999 * snapshot
1000 */
1001 ret = btrfs_run_delayed_items(trans, root);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001002 if (ret) { /* Transaction aborted */
1003 dput(parent);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001004 goto fail;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001005 }
Chris Masone9993762011-06-17 16:14:09 -04001006
Chris Mason75857172011-06-13 20:00:16 -04001007 record_root_in_trans(trans, root);
Sage Weil6bdb72d2010-03-15 17:27:13 +00001008 btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
1009 memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
Li Zefan08fe4db2011-03-28 02:01:25 +00001010 btrfs_check_and_init_root_item(new_root_item);
Sage Weil6bdb72d2010-03-15 17:27:13 +00001011
Li Zefanb83cc962010-12-20 16:04:08 +08001012 root_flags = btrfs_root_flags(new_root_item);
1013 if (pending->readonly)
1014 root_flags |= BTRFS_ROOT_SUBVOL_RDONLY;
1015 else
1016 root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY;
1017 btrfs_set_root_flags(new_root_item, root_flags);
1018
Chris Mason925baed2008-06-25 16:01:30 -04001019 old = btrfs_lock_root_node(root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001020 ret = btrfs_cow_block(trans, root, old, NULL, 0, &old);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001021 if (ret) {
1022 btrfs_tree_unlock(old);
1023 free_extent_buffer(old);
1024 goto abort_trans_dput;
1025 }
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001026
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001027 btrfs_set_lock_blocking(old);
Chris Mason3063d292008-01-08 15:46:30 -05001028
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001029 ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001030 /* clean up in any case */
Chris Mason925baed2008-06-25 16:01:30 -04001031 btrfs_tree_unlock(old);
1032 free_extent_buffer(old);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001033 if (ret)
1034 goto abort_trans_dput;
Chris Mason3063d292008-01-08 15:46:30 -05001035
Liu Bof1ebcc72011-11-14 20:48:06 -05001036 /* see comments in should_cow_block() */
1037 root->force_cow = 1;
1038 smp_wmb();
1039
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001040 btrfs_set_root_node(new_root_item, tmp);
Yan, Zhenga22285a2010-05-16 10:48:46 -04001041 /* record when the snapshot was created in key.offset */
1042 key.offset = trans->transid;
1043 ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
Chris Mason925baed2008-06-25 16:01:30 -04001044 btrfs_tree_unlock(tmp);
Chris Mason3063d292008-01-08 15:46:30 -05001045 free_extent_buffer(tmp);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001046 if (ret)
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001047 goto abort_trans_dput;
Chris Mason0660b5a2008-11-17 20:37:39 -05001048
Yan, Zhenga22285a2010-05-16 10:48:46 -04001049 /*
1050 * insert root back/forward references
1051 */
1052 ret = btrfs_add_root_ref(trans, tree_root, objectid,
1053 parent_root->root_key.objectid,
Li Zefan33345d012011-04-20 10:31:50 +08001054 btrfs_ino(parent_inode), index,
Yan, Zhenga22285a2010-05-16 10:48:46 -04001055 dentry->d_name.name, dentry->d_name.len);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001056 dput(parent);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001057 if (ret)
1058 goto fail;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001059
1060 key.offset = (u64)-1;
1061 pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001062 if (IS_ERR(pending->snap)) {
1063 ret = PTR_ERR(pending->snap);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001064 goto abort_trans;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001065 }
Yan, Zhengd68fc572010-05-16 10:49:58 -04001066
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001067 ret = btrfs_reloc_post_snapshot(trans, pending);
1068 if (ret)
1069 goto abort_trans;
1070 ret = 0;
Chris Mason3063d292008-01-08 15:46:30 -05001071fail:
Sage Weil6bdb72d2010-03-15 17:27:13 +00001072 kfree(new_root_item);
Liu Bo98c99422011-09-11 10:52:24 -04001073 trans->block_rsv = rsv;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001074 btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001075 return ret;
1076
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001077abort_trans_dput:
1078 dput(parent);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001079abort_trans:
1080 btrfs_abort_transaction(trans, root, ret);
1081 goto fail;
Chris Mason3063d292008-01-08 15:46:30 -05001082}
1083
Chris Masond352ac62008-09-29 15:18:18 -04001084/*
1085 * create all the snapshots we've scheduled for creation
1086 */
Chris Mason80b67942008-02-01 16:35:04 -05001087static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
1088 struct btrfs_fs_info *fs_info)
Chris Mason3063d292008-01-08 15:46:30 -05001089{
1090 struct btrfs_pending_snapshot *pending;
1091 struct list_head *head = &trans->transaction->pending_snapshots;
Chris Mason3de45862008-11-17 21:02:50 -05001092
Chris Masonfe66a052012-02-20 08:40:56 -05001093 list_for_each_entry(pending, head, list)
1094 create_pending_snapshot(trans, fs_info, pending);
Chris Mason3de45862008-11-17 21:02:50 -05001095 return 0;
1096}
1097
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001098static void update_super_roots(struct btrfs_root *root)
1099{
1100 struct btrfs_root_item *root_item;
1101 struct btrfs_super_block *super;
1102
David Sterba6c417612011-04-13 15:41:04 +02001103 super = root->fs_info->super_copy;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001104
1105 root_item = &root->fs_info->chunk_root->root_item;
1106 super->chunk_root = root_item->bytenr;
1107 super->chunk_root_generation = root_item->generation;
1108 super->chunk_root_level = root_item->level;
1109
1110 root_item = &root->fs_info->tree_root->root_item;
1111 super->root = root_item->bytenr;
1112 super->generation = root_item->generation;
1113 super->root_level = root_item->level;
Josef Bacik73bc1872011-10-03 14:07:49 -04001114 if (btrfs_test_opt(root, SPACE_CACHE))
Josef Bacik0af3d002010-06-21 14:48:16 -04001115 super->cache_generation = root_item->generation;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001116}
1117
Chris Masonf36f3042009-07-30 10:04:48 -04001118int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
1119{
1120 int ret = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -04001121 spin_lock(&info->trans_lock);
Chris Masonf36f3042009-07-30 10:04:48 -04001122 if (info->running_transaction)
1123 ret = info->running_transaction->in_commit;
Josef Bacika4abeea2011-04-11 17:25:13 -04001124 spin_unlock(&info->trans_lock);
Chris Masonf36f3042009-07-30 10:04:48 -04001125 return ret;
1126}
1127
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001128int btrfs_transaction_blocked(struct btrfs_fs_info *info)
1129{
1130 int ret = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -04001131 spin_lock(&info->trans_lock);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001132 if (info->running_transaction)
1133 ret = info->running_transaction->blocked;
Josef Bacika4abeea2011-04-11 17:25:13 -04001134 spin_unlock(&info->trans_lock);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001135 return ret;
1136}
1137
Sage Weilbb9c12c2010-10-29 15:37:34 -04001138/*
1139 * wait for the current transaction commit to start and block subsequent
1140 * transaction joins
1141 */
1142static void wait_current_trans_commit_start(struct btrfs_root *root,
1143 struct btrfs_transaction *trans)
1144{
Li Zefan72d63ed2011-07-14 03:17:00 +00001145 wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001146}
1147
1148/*
1149 * wait for the current transaction to start and then become unblocked.
1150 * caller holds ref.
1151 */
1152static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root,
1153 struct btrfs_transaction *trans)
1154{
Li Zefan72d63ed2011-07-14 03:17:00 +00001155 wait_event(root->fs_info->transaction_wait,
1156 trans->commit_done || (trans->in_commit && !trans->blocked));
Sage Weilbb9c12c2010-10-29 15:37:34 -04001157}
1158
1159/*
1160 * commit transactions asynchronously. once btrfs_commit_transaction_async
1161 * returns, any subsequent transaction will not be allowed to join.
1162 */
1163struct btrfs_async_commit {
1164 struct btrfs_trans_handle *newtrans;
1165 struct btrfs_root *root;
1166 struct delayed_work work;
1167};
1168
1169static void do_async_commit(struct work_struct *work)
1170{
1171 struct btrfs_async_commit *ac =
1172 container_of(work, struct btrfs_async_commit, work.work);
1173
1174 btrfs_commit_transaction(ac->newtrans, ac->root);
1175 kfree(ac);
1176}
1177
1178int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
1179 struct btrfs_root *root,
1180 int wait_for_unblock)
1181{
1182 struct btrfs_async_commit *ac;
1183 struct btrfs_transaction *cur_trans;
1184
1185 ac = kmalloc(sizeof(*ac), GFP_NOFS);
Tsutomu Itohdb5b4932011-03-23 08:14:16 +00001186 if (!ac)
1187 return -ENOMEM;
Sage Weilbb9c12c2010-10-29 15:37:34 -04001188
1189 INIT_DELAYED_WORK(&ac->work, do_async_commit);
1190 ac->root = root;
Josef Bacik7a7eaa42011-04-13 12:54:33 -04001191 ac->newtrans = btrfs_join_transaction(root);
Tsutomu Itoh3612b492011-01-25 02:51:38 +00001192 if (IS_ERR(ac->newtrans)) {
1193 int err = PTR_ERR(ac->newtrans);
1194 kfree(ac);
1195 return err;
1196 }
Sage Weilbb9c12c2010-10-29 15:37:34 -04001197
1198 /* take transaction reference */
Sage Weilbb9c12c2010-10-29 15:37:34 -04001199 cur_trans = trans->transaction;
Josef Bacik13c5a932011-04-11 15:45:29 -04001200 atomic_inc(&cur_trans->use_count);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001201
1202 btrfs_end_transaction(trans, root);
1203 schedule_delayed_work(&ac->work, 0);
1204
1205 /* wait for transaction to start and unblock */
Sage Weilbb9c12c2010-10-29 15:37:34 -04001206 if (wait_for_unblock)
1207 wait_current_trans_commit_start_and_unblock(root, cur_trans);
1208 else
1209 wait_current_trans_commit_start(root, cur_trans);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001210
Sage Weil38e88052011-06-10 18:43:13 +00001211 if (current->journal_info == trans)
1212 current->journal_info = NULL;
1213
1214 put_transaction(cur_trans);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001215 return 0;
1216}
1217
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001218
1219static void cleanup_transaction(struct btrfs_trans_handle *trans,
Josef Bacik7b8b92a2012-05-31 15:52:43 -04001220 struct btrfs_root *root, int err)
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001221{
1222 struct btrfs_transaction *cur_trans = trans->transaction;
1223
1224 WARN_ON(trans->use_count > 1);
1225
Josef Bacik7b8b92a2012-05-31 15:52:43 -04001226 btrfs_abort_transaction(trans, root, err);
1227
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001228 spin_lock(&root->fs_info->trans_lock);
1229 list_del_init(&cur_trans->list);
Josef Bacikd7096fc2012-05-31 15:49:57 -04001230 if (cur_trans == root->fs_info->running_transaction) {
1231 root->fs_info->running_transaction = NULL;
1232 root->fs_info->trans_no_join = 0;
1233 }
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001234 spin_unlock(&root->fs_info->trans_lock);
1235
1236 btrfs_cleanup_one_transaction(trans->transaction, root);
1237
1238 put_transaction(cur_trans);
1239 put_transaction(cur_trans);
1240
1241 trace_btrfs_transaction_commit(root);
1242
1243 btrfs_scrub_continue(root);
1244
1245 if (current->journal_info == trans)
1246 current->journal_info = NULL;
1247
1248 kmem_cache_free(btrfs_trans_handle_cachep, trans);
1249}
1250
Sage Weilbb9c12c2010-10-29 15:37:34 -04001251/*
1252 * btrfs_transaction state sequence:
1253 * in_commit = 0, blocked = 0 (initial)
1254 * in_commit = 1, blocked = 1
1255 * blocked = 0
1256 * commit_done = 1
1257 */
Chris Mason79154b12007-03-22 15:59:16 -04001258int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
1259 struct btrfs_root *root)
1260{
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001261 unsigned long joined = 0;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001262 struct btrfs_transaction *cur_trans = trans->transaction;
Chris Mason8fd17792007-04-19 21:01:03 -04001263 struct btrfs_transaction *prev_trans = NULL;
Chris Mason79154b12007-03-22 15:59:16 -04001264 DEFINE_WAIT(wait);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001265 int ret = -EIO;
Chris Mason89573b92009-03-12 20:12:45 -04001266 int should_grow = 0;
1267 unsigned long now = get_seconds();
Sage Weildccae992009-04-02 16:59:01 -04001268 int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
Chris Mason79154b12007-03-22 15:59:16 -04001269
Chris Mason5a3f23d2009-03-31 13:27:11 -04001270 btrfs_run_ordered_operations(root, 0);
1271
Josef Bacikb24e03d2011-10-14 14:40:17 -04001272 btrfs_trans_release_metadata(trans, root);
Josef Bacik9c8d86d2011-09-19 11:58:54 -04001273 trans->block_rsv = NULL;
1274
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001275 if (cur_trans->aborted)
1276 goto cleanup_transaction;
1277
Chris Mason56bec292009-03-13 10:10:06 -04001278 /* make a pass through all the delayed refs we have so far
1279 * any runnings procs may add more while we are here
1280 */
1281 ret = btrfs_run_delayed_refs(trans, root, 0);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001282 if (ret)
1283 goto cleanup_transaction;
Chris Mason56bec292009-03-13 10:10:06 -04001284
Chris Masonb7ec40d2009-03-12 20:12:45 -04001285 cur_trans = trans->transaction;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001286
Chris Mason56bec292009-03-13 10:10:06 -04001287 /*
1288 * set the flushing flag so procs in this transaction have to
1289 * start sending their work down.
1290 */
Chris Masonb7ec40d2009-03-12 20:12:45 -04001291 cur_trans->delayed_refs.flushing = 1;
Chris Mason56bec292009-03-13 10:10:06 -04001292
Chris Masonc3e69d52009-03-13 10:17:05 -04001293 ret = btrfs_run_delayed_refs(trans, root, 0);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001294 if (ret)
1295 goto cleanup_transaction;
Chris Mason56bec292009-03-13 10:10:06 -04001296
Josef Bacika4abeea2011-04-11 17:25:13 -04001297 spin_lock(&cur_trans->commit_lock);
Chris Masonb7ec40d2009-03-12 20:12:45 -04001298 if (cur_trans->in_commit) {
Josef Bacika4abeea2011-04-11 17:25:13 -04001299 spin_unlock(&cur_trans->commit_lock);
Josef Bacik13c5a932011-04-11 15:45:29 -04001300 atomic_inc(&cur_trans->use_count);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001301 ret = btrfs_end_transaction(trans, root);
Chris Masonccd467d2007-06-28 15:57:36 -04001302
Li Zefanb9c83002011-07-14 03:17:14 +00001303 wait_for_commit(root, cur_trans);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001304
Chris Mason79154b12007-03-22 15:59:16 -04001305 put_transaction(cur_trans);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001306
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001307 return ret;
Chris Mason79154b12007-03-22 15:59:16 -04001308 }
Chris Mason4313b392008-01-03 09:08:48 -05001309
Chris Mason2c90e5d2007-04-02 10:50:19 -04001310 trans->transaction->in_commit = 1;
Chris Masonf9295742008-07-17 12:54:14 -04001311 trans->transaction->blocked = 1;
Josef Bacika4abeea2011-04-11 17:25:13 -04001312 spin_unlock(&cur_trans->commit_lock);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001313 wake_up(&root->fs_info->transaction_blocked_wait);
1314
Josef Bacika4abeea2011-04-11 17:25:13 -04001315 spin_lock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001316 if (cur_trans->list.prev != &root->fs_info->trans_list) {
1317 prev_trans = list_entry(cur_trans->list.prev,
1318 struct btrfs_transaction, list);
1319 if (!prev_trans->commit_done) {
Josef Bacik13c5a932011-04-11 15:45:29 -04001320 atomic_inc(&prev_trans->use_count);
Josef Bacika4abeea2011-04-11 17:25:13 -04001321 spin_unlock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001322
1323 wait_for_commit(root, prev_trans);
Chris Masonccd467d2007-06-28 15:57:36 -04001324
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001325 put_transaction(prev_trans);
Josef Bacika4abeea2011-04-11 17:25:13 -04001326 } else {
1327 spin_unlock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001328 }
Josef Bacika4abeea2011-04-11 17:25:13 -04001329 } else {
1330 spin_unlock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001331 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001332
Chris Masone39e64a2012-07-23 15:23:45 -04001333 if (!btrfs_test_opt(root, SSD) &&
1334 (now < cur_trans->start_time || now - cur_trans->start_time < 1))
Chris Mason89573b92009-03-12 20:12:45 -04001335 should_grow = 1;
1336
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001337 do {
Yan Zheng7ea394f2008-08-05 13:05:02 -04001338 int snap_pending = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -04001339
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001340 joined = cur_trans->num_joined;
Yan Zheng7ea394f2008-08-05 13:05:02 -04001341 if (!list_empty(&trans->transaction->pending_snapshots))
1342 snap_pending = 1;
1343
Chris Mason2c90e5d2007-04-02 10:50:19 -04001344 WARN_ON(cur_trans != trans->transaction);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001345
Sage Weil0bdb1db2010-02-19 14:13:50 -08001346 if (flush_on_commit || snap_pending) {
Yan, Zheng24bbcf02009-11-12 09:36:34 +00001347 btrfs_start_delalloc_inodes(root, 1);
Jeff Mahoney143bede2012-03-01 14:56:26 +01001348 btrfs_wait_ordered_extents(root, 0, 1);
Yan Zheng7ea394f2008-08-05 13:05:02 -04001349 }
1350
Miao Xie16cdcec2011-04-22 18:12:22 +08001351 ret = btrfs_run_delayed_items(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001352 if (ret)
1353 goto cleanup_transaction;
Miao Xie16cdcec2011-04-22 18:12:22 +08001354
Chris Mason5a3f23d2009-03-31 13:27:11 -04001355 /*
1356 * rename don't use btrfs_join_transaction, so, once we
1357 * set the transaction to blocked above, we aren't going
1358 * to get any new ordered operations. We can safely run
1359 * it here and no for sure that nothing new will be added
1360 * to the list
1361 */
1362 btrfs_run_ordered_operations(root, 1);
1363
Chris Masoned3b3d3142010-05-25 10:12:41 -04001364 prepare_to_wait(&cur_trans->writer_wait, &wait,
1365 TASK_UNINTERRUPTIBLE);
1366
Josef Bacik13c5a932011-04-11 15:45:29 -04001367 if (atomic_read(&cur_trans->num_writers) > 1)
Sage Weil99d16cb2010-10-29 15:37:34 -04001368 schedule_timeout(MAX_SCHEDULE_TIMEOUT);
1369 else if (should_grow)
1370 schedule_timeout(1);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001371
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001372 finish_wait(&cur_trans->writer_wait, &wait);
Josef Bacik13c5a932011-04-11 15:45:29 -04001373 } while (atomic_read(&cur_trans->num_writers) > 1 ||
Chris Mason89573b92009-03-12 20:12:45 -04001374 (should_grow && cur_trans->num_joined != joined));
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001375
Chris Mason75857172011-06-13 20:00:16 -04001376 /*
Josef Baciked0ca142011-06-14 16:22:15 -04001377 * Ok now we need to make sure to block out any other joins while we
1378 * commit the transaction. We could have started a join before setting
1379 * no_join so make sure to wait for num_writers to == 1 again.
1380 */
1381 spin_lock(&root->fs_info->trans_lock);
1382 root->fs_info->trans_no_join = 1;
1383 spin_unlock(&root->fs_info->trans_lock);
1384 wait_event(cur_trans->writer_wait,
1385 atomic_read(&cur_trans->num_writers) == 1);
1386
Chris Masone038dca2011-06-17 14:16:13 -04001387 /*
Chris Mason75857172011-06-13 20:00:16 -04001388 * the reloc mutex makes sure that we stop
1389 * the balancing code from coming in and moving
1390 * extents around in the middle of the commit
1391 */
1392 mutex_lock(&root->fs_info->reloc_mutex);
1393
Chris Masone9993762011-06-17 16:14:09 -04001394 ret = btrfs_run_delayed_items(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001395 if (ret) {
1396 mutex_unlock(&root->fs_info->reloc_mutex);
1397 goto cleanup_transaction;
1398 }
Chris Mason3063d292008-01-08 15:46:30 -05001399
Chris Masone9993762011-06-17 16:14:09 -04001400 ret = create_pending_snapshots(trans, root->fs_info);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001401 if (ret) {
1402 mutex_unlock(&root->fs_info->reloc_mutex);
1403 goto cleanup_transaction;
1404 }
Miao Xie16cdcec2011-04-22 18:12:22 +08001405
Chris Mason56bec292009-03-13 10:10:06 -04001406 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001407 if (ret) {
1408 mutex_unlock(&root->fs_info->reloc_mutex);
1409 goto cleanup_transaction;
1410 }
Chris Mason56bec292009-03-13 10:10:06 -04001411
Chris Masone9993762011-06-17 16:14:09 -04001412 /*
1413 * make sure none of the code above managed to slip in a
1414 * delayed item
1415 */
1416 btrfs_assert_delayed_root_empty(root);
1417
Chris Mason2c90e5d2007-04-02 10:50:19 -04001418 WARN_ON(cur_trans != trans->transaction);
Chris Masondc17ff82008-01-08 15:46:30 -05001419
Arne Jansena2de7332011-03-08 14:14:00 +01001420 btrfs_scrub_pause(root);
Chris Masone02119d2008-09-05 16:13:11 -04001421 /* btrfs_commit_tree_roots is responsible for getting the
1422 * various roots consistent with each other. Every pointer
1423 * in the tree of tree roots has to point to the most up to date
1424 * root for every subvolume and other tree. So, we have to keep
1425 * the tree logging code from jumping in and changing any
1426 * of the trees.
1427 *
1428 * At this point in the commit, there can't be any tree-log
1429 * writers, but a little lower down we drop the trans mutex
1430 * and let new people in. By holding the tree_log_mutex
1431 * from now until after the super is written, we avoid races
1432 * with the tree-log code.
1433 */
1434 mutex_lock(&root->fs_info->tree_log_mutex);
Zheng Yan1a40e232008-09-26 10:09:34 -04001435
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001436 ret = commit_fs_roots(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001437 if (ret) {
1438 mutex_unlock(&root->fs_info->tree_log_mutex);
David Sterba871383b2012-04-02 18:31:37 +02001439 mutex_unlock(&root->fs_info->reloc_mutex);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001440 goto cleanup_transaction;
1441 }
Chris Mason54aa1f42007-06-22 14:16:25 -04001442
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001443 /* commit_fs_roots gets rid of all the tree log roots, it is now
Chris Masone02119d2008-09-05 16:13:11 -04001444 * safe to free the root of tree log roots
1445 */
1446 btrfs_free_log_root_tree(trans, root->fs_info);
1447
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001448 ret = commit_cowonly_roots(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001449 if (ret) {
1450 mutex_unlock(&root->fs_info->tree_log_mutex);
David Sterba871383b2012-04-02 18:31:37 +02001451 mutex_unlock(&root->fs_info->reloc_mutex);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001452 goto cleanup_transaction;
1453 }
Chris Mason54aa1f42007-06-22 14:16:25 -04001454
Yan Zheng11833d62009-09-11 16:11:19 -04001455 btrfs_prepare_extent_commit(trans, root);
1456
Chris Mason78fae272007-03-25 11:35:08 -04001457 cur_trans = root->fs_info->running_transaction;
Chris Mason5f39d392007-10-15 16:14:19 -04001458
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001459 btrfs_set_root_node(&root->fs_info->tree_root->root_item,
1460 root->fs_info->tree_root->node);
Josef Bacik817d52f2009-07-13 21:29:25 -04001461 switch_commit_root(root->fs_info->tree_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001462
1463 btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
1464 root->fs_info->chunk_root->node);
Josef Bacik817d52f2009-07-13 21:29:25 -04001465 switch_commit_root(root->fs_info->chunk_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001466
1467 update_super_roots(root);
Chris Masone02119d2008-09-05 16:13:11 -04001468
1469 if (!root->fs_info->log_root_recovering) {
David Sterba6c417612011-04-13 15:41:04 +02001470 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
1471 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
Chris Masone02119d2008-09-05 16:13:11 -04001472 }
1473
David Sterba6c417612011-04-13 15:41:04 +02001474 memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
1475 sizeof(*root->fs_info->super_copy));
Chris Masonccd467d2007-06-28 15:57:36 -04001476
Chris Masonf9295742008-07-17 12:54:14 -04001477 trans->transaction->blocked = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -04001478 spin_lock(&root->fs_info->trans_lock);
1479 root->fs_info->running_transaction = NULL;
1480 root->fs_info->trans_no_join = 0;
1481 spin_unlock(&root->fs_info->trans_lock);
Chris Mason75857172011-06-13 20:00:16 -04001482 mutex_unlock(&root->fs_info->reloc_mutex);
Chris Masonb7ec40d2009-03-12 20:12:45 -04001483
Chris Masonf9295742008-07-17 12:54:14 -04001484 wake_up(&root->fs_info->transaction_wait);
Chris Masone6dcd2d2008-07-17 12:53:50 -04001485
Chris Mason79154b12007-03-22 15:59:16 -04001486 ret = btrfs_write_and_wait_transaction(trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001487 if (ret) {
1488 btrfs_error(root->fs_info, ret,
1489 "Error while writing out transaction.");
1490 mutex_unlock(&root->fs_info->tree_log_mutex);
1491 goto cleanup_transaction;
1492 }
1493
1494 ret = write_ctree_super(trans, root, 0);
1495 if (ret) {
1496 mutex_unlock(&root->fs_info->tree_log_mutex);
1497 goto cleanup_transaction;
1498 }
Chris Mason4313b392008-01-03 09:08:48 -05001499
Chris Masone02119d2008-09-05 16:13:11 -04001500 /*
1501 * the super is written, we can safely allow the tree-loggers
1502 * to go about their business
1503 */
1504 mutex_unlock(&root->fs_info->tree_log_mutex);
1505
Yan Zheng11833d62009-09-11 16:11:19 -04001506 btrfs_finish_extent_commit(trans, root);
Chris Mason4313b392008-01-03 09:08:48 -05001507
Chris Mason2c90e5d2007-04-02 10:50:19 -04001508 cur_trans->commit_done = 1;
Chris Masonb7ec40d2009-03-12 20:12:45 -04001509
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001510 root->fs_info->last_trans_committed = cur_trans->transid;
Josef Bacik817d52f2009-07-13 21:29:25 -04001511
Chris Mason2c90e5d2007-04-02 10:50:19 -04001512 wake_up(&cur_trans->commit_wait);
Chris Mason3de45862008-11-17 21:02:50 -05001513
Josef Bacika4abeea2011-04-11 17:25:13 -04001514 spin_lock(&root->fs_info->trans_lock);
Josef Bacik13c5a932011-04-11 15:45:29 -04001515 list_del_init(&cur_trans->list);
Josef Bacika4abeea2011-04-11 17:25:13 -04001516 spin_unlock(&root->fs_info->trans_lock);
1517
Chris Mason79154b12007-03-22 15:59:16 -04001518 put_transaction(cur_trans);
Chris Mason78fae272007-03-25 11:35:08 -04001519 put_transaction(cur_trans);
Josef Bacik58176a92007-08-29 15:47:34 -04001520
liubo1abe9b82011-03-24 11:18:59 +00001521 trace_btrfs_transaction_commit(root);
1522
Arne Jansena2de7332011-03-08 14:14:00 +01001523 btrfs_scrub_continue(root);
1524
Josef Bacik9ed74f22009-09-11 16:12:44 -04001525 if (current->journal_info == trans)
1526 current->journal_info = NULL;
1527
Chris Mason2c90e5d2007-04-02 10:50:19 -04001528 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Yan, Zheng24bbcf02009-11-12 09:36:34 +00001529
1530 if (current != root->fs_info->transaction_kthread)
1531 btrfs_run_delayed_iputs(root);
1532
Chris Mason79154b12007-03-22 15:59:16 -04001533 return ret;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001534
1535cleanup_transaction:
1536 btrfs_printk(root->fs_info, "Skipping commit of aborted transaction.\n");
1537// WARN_ON(1);
1538 if (current->journal_info == trans)
1539 current->journal_info = NULL;
Josef Bacik7b8b92a2012-05-31 15:52:43 -04001540 cleanup_transaction(trans, root, ret);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001541
1542 return ret;
Chris Mason79154b12007-03-22 15:59:16 -04001543}
1544
Chris Masond352ac62008-09-29 15:18:18 -04001545/*
1546 * interface function to delete all the snapshots we have scheduled for deletion
1547 */
Chris Masone9d0b132007-08-10 14:06:19 -04001548int btrfs_clean_old_snapshots(struct btrfs_root *root)
1549{
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001550 LIST_HEAD(list);
1551 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Masone9d0b132007-08-10 14:06:19 -04001552
Josef Bacika4abeea2011-04-11 17:25:13 -04001553 spin_lock(&fs_info->trans_lock);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001554 list_splice_init(&fs_info->dead_roots, &list);
Josef Bacika4abeea2011-04-11 17:25:13 -04001555 spin_unlock(&fs_info->trans_lock);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001556
1557 while (!list_empty(&list)) {
Jeff Mahoney2c536792011-10-03 23:22:41 -04001558 int ret;
1559
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001560 root = list_entry(list.next, struct btrfs_root, root_list);
Yan, Zheng76dda932009-09-21 16:00:26 -04001561 list_del(&root->root_list);
1562
Miao Xie16cdcec2011-04-22 18:12:22 +08001563 btrfs_kill_all_delayed_nodes(root);
1564
Yan, Zheng76dda932009-09-21 16:00:26 -04001565 if (btrfs_header_backref_rev(root->node) <
1566 BTRFS_MIXED_BACKREF_REV)
Jeff Mahoney2c536792011-10-03 23:22:41 -04001567 ret = btrfs_drop_snapshot(root, NULL, 0, 0);
Yan, Zheng76dda932009-09-21 16:00:26 -04001568 else
Jeff Mahoney2c536792011-10-03 23:22:41 -04001569 ret =btrfs_drop_snapshot(root, NULL, 1, 0);
1570 BUG_ON(ret < 0);
Chris Masone9d0b132007-08-10 14:06:19 -04001571 }
1572 return 0;
1573}