blob: d5f987b49d70aa8583c598792a926613c59f912a [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"
Chris Mason79154b12007-03-22 15:59:16 -040031
Chris Mason0f7d52f2007-04-09 10:42:37 -040032#define BTRFS_ROOT_TRANS_TAG 0
33
Chris Mason80b67942008-02-01 16:35:04 -050034static noinline void put_transaction(struct btrfs_transaction *transaction)
Chris Mason79154b12007-03-22 15:59:16 -040035{
Josef Bacik13c5a932011-04-11 15:45:29 -040036 WARN_ON(atomic_read(&transaction->use_count) == 0);
37 if (atomic_dec_and_test(&transaction->use_count)) {
Josef Bacika4abeea2011-04-11 17:25:13 -040038 BUG_ON(!list_empty(&transaction->list));
Arne Jansen00f04b82011-09-14 12:37:00 +020039 WARN_ON(transaction->delayed_refs.root.rb_node);
40 WARN_ON(!list_empty(&transaction->delayed_refs.seq_head));
Chris Mason2c90e5d2007-04-02 10:50:19 -040041 memset(transaction, 0, sizeof(*transaction));
42 kmem_cache_free(btrfs_transaction_cachep, transaction);
Chris Mason78fae272007-03-25 11:35:08 -040043 }
Chris Mason79154b12007-03-22 15:59:16 -040044}
45
Josef Bacik817d52f2009-07-13 21:29:25 -040046static noinline void switch_commit_root(struct btrfs_root *root)
47{
Josef Bacik817d52f2009-07-13 21:29:25 -040048 free_extent_buffer(root->commit_root);
49 root->commit_root = btrfs_root_node(root);
Josef Bacik817d52f2009-07-13 21:29:25 -040050}
51
Chris Masond352ac62008-09-29 15:18:18 -040052/*
53 * either allocate a new transaction or hop into the existing one
54 */
Josef Bacika4abeea2011-04-11 17:25:13 -040055static noinline int join_transaction(struct btrfs_root *root, int nofail)
Chris Mason79154b12007-03-22 15:59:16 -040056{
57 struct btrfs_transaction *cur_trans;
Josef Bacika4abeea2011-04-11 17:25:13 -040058
59 spin_lock(&root->fs_info->trans_lock);
Chris Masond43317d2011-11-06 03:26:19 -050060loop:
Josef Bacika4abeea2011-04-11 17:25:13 -040061 if (root->fs_info->trans_no_join) {
62 if (!nofail) {
63 spin_unlock(&root->fs_info->trans_lock);
64 return -EBUSY;
65 }
66 }
67
Chris Mason79154b12007-03-22 15:59:16 -040068 cur_trans = root->fs_info->running_transaction;
Josef Bacika4abeea2011-04-11 17:25:13 -040069 if (cur_trans) {
70 atomic_inc(&cur_trans->use_count);
Josef Bacik13c5a932011-04-11 15:45:29 -040071 atomic_inc(&cur_trans->num_writers);
Josef Bacik15ee9bc2007-08-10 16:22:09 -040072 cur_trans->num_joined++;
Josef Bacika4abeea2011-04-11 17:25:13 -040073 spin_unlock(&root->fs_info->trans_lock);
74 return 0;
Chris Mason79154b12007-03-22 15:59:16 -040075 }
Josef Bacika4abeea2011-04-11 17:25:13 -040076 spin_unlock(&root->fs_info->trans_lock);
77
78 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
79 if (!cur_trans)
80 return -ENOMEM;
Chris Masond43317d2011-11-06 03:26:19 -050081
Josef Bacika4abeea2011-04-11 17:25:13 -040082 spin_lock(&root->fs_info->trans_lock);
83 if (root->fs_info->running_transaction) {
Chris Masond43317d2011-11-06 03:26:19 -050084 /*
85 * someone started a transaction after we unlocked. Make sure
86 * to redo the trans_no_join checks above
87 */
Josef Bacika4abeea2011-04-11 17:25:13 -040088 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
89 cur_trans = root->fs_info->running_transaction;
Chris Masond43317d2011-11-06 03:26:19 -050090 goto loop;
Josef Bacika4abeea2011-04-11 17:25:13 -040091 }
Chris Masond43317d2011-11-06 03:26:19 -050092
Josef Bacika4abeea2011-04-11 17:25:13 -040093 atomic_set(&cur_trans->num_writers, 1);
94 cur_trans->num_joined = 0;
95 init_waitqueue_head(&cur_trans->writer_wait);
96 init_waitqueue_head(&cur_trans->commit_wait);
97 cur_trans->in_commit = 0;
98 cur_trans->blocked = 0;
99 /*
100 * One for this trans handle, one so it will live on until we
101 * commit the transaction.
102 */
103 atomic_set(&cur_trans->use_count, 2);
104 cur_trans->commit_done = 0;
105 cur_trans->start_time = get_seconds();
106
107 cur_trans->delayed_refs.root = RB_ROOT;
108 cur_trans->delayed_refs.num_entries = 0;
109 cur_trans->delayed_refs.num_heads_ready = 0;
110 cur_trans->delayed_refs.num_heads = 0;
111 cur_trans->delayed_refs.flushing = 0;
112 cur_trans->delayed_refs.run_delayed_start = 0;
Arne Jansen00f04b82011-09-14 12:37:00 +0200113 cur_trans->delayed_refs.seq = 1;
Jan Schmidta1686502011-12-12 16:10:07 +0100114 init_waitqueue_head(&cur_trans->delayed_refs.seq_wait);
Josef Bacika4abeea2011-04-11 17:25:13 -0400115 spin_lock_init(&cur_trans->commit_lock);
116 spin_lock_init(&cur_trans->delayed_refs.lock);
Arne Jansen00f04b82011-09-14 12:37:00 +0200117 INIT_LIST_HEAD(&cur_trans->delayed_refs.seq_head);
Josef Bacika4abeea2011-04-11 17:25:13 -0400118
119 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
120 list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
121 extent_io_tree_init(&cur_trans->dirty_pages,
Chris Masonff5714c2011-05-28 07:00:39 -0400122 root->fs_info->btree_inode->i_mapping);
Josef Bacika4abeea2011-04-11 17:25:13 -0400123 root->fs_info->generation++;
124 cur_trans->transid = root->fs_info->generation;
125 root->fs_info->running_transaction = cur_trans;
126 spin_unlock(&root->fs_info->trans_lock);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400127
Chris Mason79154b12007-03-22 15:59:16 -0400128 return 0;
129}
130
Chris Masond352ac62008-09-29 15:18:18 -0400131/*
Chris Masond3977122009-01-05 21:25:51 -0500132 * this does all the record keeping required to make sure that a reference
133 * counted root is properly recorded in a given transaction. This is required
134 * to make sure the old root from before we joined the transaction is deleted
135 * when the transaction commits
Chris Masond352ac62008-09-29 15:18:18 -0400136 */
Chris Mason75857172011-06-13 20:00:16 -0400137static int record_root_in_trans(struct btrfs_trans_handle *trans,
Josef Bacika4abeea2011-04-11 17:25:13 -0400138 struct btrfs_root *root)
Chris Mason6702ed42007-08-07 16:15:09 -0400139{
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400140 if (root->ref_cows && root->last_trans < trans->transid) {
Chris Mason6702ed42007-08-07 16:15:09 -0400141 WARN_ON(root == root->fs_info->extent_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400142 WARN_ON(root->commit_root != root->node);
Yan Zheng31153d82008-07-28 15:32:19 -0400143
Chris Mason75857172011-06-13 20:00:16 -0400144 /*
145 * see below for in_trans_setup usage rules
146 * we have the reloc mutex held now, so there
147 * is only one writer in this function
148 */
149 root->in_trans_setup = 1;
150
151 /* make sure readers find in_trans_setup before
152 * they find our root->last_trans update
153 */
154 smp_wmb();
155
Josef Bacika4abeea2011-04-11 17:25:13 -0400156 spin_lock(&root->fs_info->fs_roots_radix_lock);
157 if (root->last_trans == trans->transid) {
158 spin_unlock(&root->fs_info->fs_roots_radix_lock);
159 return 0;
160 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400161 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
162 (unsigned long)root->root_key.objectid,
163 BTRFS_ROOT_TRANS_TAG);
Josef Bacika4abeea2011-04-11 17:25:13 -0400164 spin_unlock(&root->fs_info->fs_roots_radix_lock);
Chris Mason75857172011-06-13 20:00:16 -0400165 root->last_trans = trans->transid;
166
167 /* this is pretty tricky. We don't want to
168 * take the relocation lock in btrfs_record_root_in_trans
169 * unless we're really doing the first setup for this root in
170 * this transaction.
171 *
172 * Normally we'd use root->last_trans as a flag to decide
173 * if we want to take the expensive mutex.
174 *
175 * But, we have to set root->last_trans before we
176 * init the relocation root, otherwise, we trip over warnings
177 * in ctree.c. The solution used here is to flag ourselves
178 * with root->in_trans_setup. When this is 1, we're still
179 * fixing up the reloc trees and everyone must wait.
180 *
181 * When this is zero, they can trust root->last_trans and fly
182 * through btrfs_record_root_in_trans without having to take the
183 * lock. smp_wmb() makes sure that all the writes above are
184 * done before we pop in the zero below
185 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400186 btrfs_init_reloc_root(trans, root);
Chris Mason75857172011-06-13 20:00:16 -0400187 smp_wmb();
188 root->in_trans_setup = 0;
Chris Mason6702ed42007-08-07 16:15:09 -0400189 }
190 return 0;
191}
192
Chris Mason75857172011-06-13 20:00:16 -0400193
194int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
195 struct btrfs_root *root)
196{
197 if (!root->ref_cows)
198 return 0;
199
200 /*
201 * see record_root_in_trans for comments about in_trans_setup usage
202 * and barriers
203 */
204 smp_rmb();
205 if (root->last_trans == trans->transid &&
206 !root->in_trans_setup)
207 return 0;
208
209 mutex_lock(&root->fs_info->reloc_mutex);
210 record_root_in_trans(trans, root);
211 mutex_unlock(&root->fs_info->reloc_mutex);
212
213 return 0;
214}
215
Chris Masond352ac62008-09-29 15:18:18 -0400216/* wait for commit against the current transaction to become unblocked
217 * when this is done, it is safe to start a new transaction, but the current
218 * transaction might not be fully on disk.
219 */
Chris Mason37d1aee2008-07-31 10:48:37 -0400220static void wait_current_trans(struct btrfs_root *root)
Chris Mason79154b12007-03-22 15:59:16 -0400221{
Chris Masonf9295742008-07-17 12:54:14 -0400222 struct btrfs_transaction *cur_trans;
Chris Mason79154b12007-03-22 15:59:16 -0400223
Josef Bacika4abeea2011-04-11 17:25:13 -0400224 spin_lock(&root->fs_info->trans_lock);
Chris Masonf9295742008-07-17 12:54:14 -0400225 cur_trans = root->fs_info->running_transaction;
Chris Mason37d1aee2008-07-31 10:48:37 -0400226 if (cur_trans && cur_trans->blocked) {
Josef Bacik13c5a932011-04-11 15:45:29 -0400227 atomic_inc(&cur_trans->use_count);
Josef Bacika4abeea2011-04-11 17:25:13 -0400228 spin_unlock(&root->fs_info->trans_lock);
Li Zefan72d63ed2011-07-14 03:17:00 +0000229
230 wait_event(root->fs_info->transaction_wait,
231 !cur_trans->blocked);
Chris Masonf9295742008-07-17 12:54:14 -0400232 put_transaction(cur_trans);
Josef Bacika4abeea2011-04-11 17:25:13 -0400233 } else {
234 spin_unlock(&root->fs_info->trans_lock);
Chris Masonf9295742008-07-17 12:54:14 -0400235 }
Chris Mason37d1aee2008-07-31 10:48:37 -0400236}
237
Josef Bacik249ac1e2009-11-10 21:23:48 -0500238enum btrfs_trans_type {
239 TRANS_START,
240 TRANS_JOIN,
241 TRANS_USERSPACE,
Josef Bacik0af3d002010-06-21 14:48:16 -0400242 TRANS_JOIN_NOLOCK,
Josef Bacik249ac1e2009-11-10 21:23:48 -0500243};
244
Yan, Zhenga22285a2010-05-16 10:48:46 -0400245static int may_wait_transaction(struct btrfs_root *root, int type)
Chris Mason37d1aee2008-07-31 10:48:37 -0400246{
Josef Bacika4abeea2011-04-11 17:25:13 -0400247 if (root->fs_info->log_root_recovering)
248 return 0;
249
250 if (type == TRANS_USERSPACE)
Yan, Zhenga22285a2010-05-16 10:48:46 -0400251 return 1;
Josef Bacika4abeea2011-04-11 17:25:13 -0400252
253 if (type == TRANS_START &&
254 !atomic_read(&root->fs_info->open_ioctl_trans))
255 return 1;
256
Yan, Zhenga22285a2010-05-16 10:48:46 -0400257 return 0;
258}
259
260static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
261 u64 num_items, int type)
262{
263 struct btrfs_trans_handle *h;
264 struct btrfs_transaction *cur_trans;
Josef Bacikb5009942011-06-07 15:07:51 -0400265 u64 num_bytes = 0;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400266 int ret;
liuboacce9522011-01-06 19:30:25 +0800267
268 if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
269 return ERR_PTR(-EROFS);
Josef Bacik2a1eb462011-04-13 15:15:59 -0400270
271 if (current->journal_info) {
272 WARN_ON(type != TRANS_JOIN && type != TRANS_JOIN_NOLOCK);
273 h = current->journal_info;
274 h->use_count++;
275 h->orig_rsv = h->block_rsv;
276 h->block_rsv = NULL;
277 goto got_it;
278 }
Josef Bacikb5009942011-06-07 15:07:51 -0400279
280 /*
281 * Do the reservation before we join the transaction so we can do all
282 * the appropriate flushing if need be.
283 */
284 if (num_items > 0 && root != root->fs_info->chunk_root) {
285 num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
Josef Bacik4a92b1b2011-08-30 12:34:28 -0400286 ret = btrfs_block_rsv_add(root,
Josef Bacikb5009942011-06-07 15:07:51 -0400287 &root->fs_info->trans_block_rsv,
288 num_bytes);
289 if (ret)
290 return ERR_PTR(ret);
291 }
Yan, Zhenga22285a2010-05-16 10:48:46 -0400292again:
293 h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
294 if (!h)
295 return ERR_PTR(-ENOMEM);
296
Yan, Zhenga22285a2010-05-16 10:48:46 -0400297 if (may_wait_transaction(root, type))
Chris Mason37d1aee2008-07-31 10:48:37 -0400298 wait_current_trans(root);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400299
Josef Bacika4abeea2011-04-11 17:25:13 -0400300 do {
301 ret = join_transaction(root, type == TRANS_JOIN_NOLOCK);
302 if (ret == -EBUSY)
303 wait_current_trans(root);
304 } while (ret == -EBUSY);
305
Tsutomu Itohdb5b4932011-03-23 08:14:16 +0000306 if (ret < 0) {
Yoshinori Sano6e8df2a2011-04-03 12:31:28 +0000307 kmem_cache_free(btrfs_trans_handle_cachep, h);
Tsutomu Itohdb5b4932011-03-23 08:14:16 +0000308 return ERR_PTR(ret);
309 }
Chris Mason0f7d52f2007-04-09 10:42:37 -0400310
Yan, Zhenga22285a2010-05-16 10:48:46 -0400311 cur_trans = root->fs_info->running_transaction;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400312
313 h->transid = cur_trans->transid;
314 h->transaction = cur_trans;
Chris Mason79154b12007-03-22 15:59:16 -0400315 h->blocks_used = 0;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400316 h->bytes_reserved = 0;
Chris Mason56bec292009-03-13 10:10:06 -0400317 h->delayed_ref_updates = 0;
Josef Bacik2a1eb462011-04-13 15:15:59 -0400318 h->use_count = 1;
Yan, Zhengf0486c62010-05-16 10:46:25 -0400319 h->block_rsv = NULL;
Josef Bacik2a1eb462011-04-13 15:15:59 -0400320 h->orig_rsv = NULL;
Chris Masonb7ec40d2009-03-12 20:12:45 -0400321
Yan, Zhenga22285a2010-05-16 10:48:46 -0400322 smp_mb();
323 if (cur_trans->blocked && may_wait_transaction(root, type)) {
324 btrfs_commit_transaction(h, root);
325 goto again;
326 }
Josef Bacik9ed74f22009-09-11 16:12:44 -0400327
Josef Bacikb5009942011-06-07 15:07:51 -0400328 if (num_bytes) {
329 h->block_rsv = &root->fs_info->trans_block_rsv;
330 h->bytes_reserved = num_bytes;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400331 }
332
Josef Bacik2a1eb462011-04-13 15:15:59 -0400333got_it:
Josef Bacika4abeea2011-04-11 17:25:13 -0400334 btrfs_record_root_in_trans(h, root);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400335
336 if (!current->journal_info && type != TRANS_USERSPACE)
337 current->journal_info = h;
Chris Mason79154b12007-03-22 15:59:16 -0400338 return h;
339}
340
Chris Masonf9295742008-07-17 12:54:14 -0400341struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
Yan, Zhenga22285a2010-05-16 10:48:46 -0400342 int num_items)
Chris Masonf9295742008-07-17 12:54:14 -0400343{
Yan, Zhenga22285a2010-05-16 10:48:46 -0400344 return start_transaction(root, num_items, TRANS_START);
Chris Masonf9295742008-07-17 12:54:14 -0400345}
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400346struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
Chris Masonf9295742008-07-17 12:54:14 -0400347{
Yan, Zhenga22285a2010-05-16 10:48:46 -0400348 return start_transaction(root, 0, TRANS_JOIN);
Chris Masonf9295742008-07-17 12:54:14 -0400349}
350
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400351struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
Josef Bacik0af3d002010-06-21 14:48:16 -0400352{
353 return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
354}
355
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400356struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
Sage Weil9ca9ee02008-08-04 10:41:27 -0400357{
Josef Bacik7a7eaa42011-04-13 12:54:33 -0400358 return start_transaction(root, 0, TRANS_USERSPACE);
Sage Weil9ca9ee02008-08-04 10:41:27 -0400359}
360
Chris Masond352ac62008-09-29 15:18:18 -0400361/* wait for a transaction commit to be fully complete */
Li Zefanb9c83002011-07-14 03:17:14 +0000362static noinline void wait_for_commit(struct btrfs_root *root,
Chris Mason89ce8a62008-06-25 16:01:31 -0400363 struct btrfs_transaction *commit)
364{
Li Zefan72d63ed2011-07-14 03:17:00 +0000365 wait_event(commit->commit_wait, commit->commit_done);
Chris Mason89ce8a62008-06-25 16:01:31 -0400366}
367
Sage Weil46204592010-10-29 15:41:32 -0400368int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
369{
370 struct btrfs_transaction *cur_trans = NULL, *t;
371 int ret;
372
Sage Weil46204592010-10-29 15:41:32 -0400373 ret = 0;
374 if (transid) {
375 if (transid <= root->fs_info->last_trans_committed)
Josef Bacika4abeea2011-04-11 17:25:13 -0400376 goto out;
Sage Weil46204592010-10-29 15:41:32 -0400377
378 /* find specified transaction */
Josef Bacika4abeea2011-04-11 17:25:13 -0400379 spin_lock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400380 list_for_each_entry(t, &root->fs_info->trans_list, list) {
381 if (t->transid == transid) {
382 cur_trans = t;
Josef Bacika4abeea2011-04-11 17:25:13 -0400383 atomic_inc(&cur_trans->use_count);
Sage Weil46204592010-10-29 15:41:32 -0400384 break;
385 }
386 if (t->transid > transid)
387 break;
388 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400389 spin_unlock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400390 ret = -EINVAL;
391 if (!cur_trans)
Josef Bacika4abeea2011-04-11 17:25:13 -0400392 goto out; /* bad transid */
Sage Weil46204592010-10-29 15:41:32 -0400393 } else {
394 /* find newest transaction that is committing | committed */
Josef Bacika4abeea2011-04-11 17:25:13 -0400395 spin_lock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400396 list_for_each_entry_reverse(t, &root->fs_info->trans_list,
397 list) {
398 if (t->in_commit) {
399 if (t->commit_done)
Josef Bacik3473f3c2011-06-09 10:15:17 -0400400 break;
Sage Weil46204592010-10-29 15:41:32 -0400401 cur_trans = t;
Josef Bacika4abeea2011-04-11 17:25:13 -0400402 atomic_inc(&cur_trans->use_count);
Sage Weil46204592010-10-29 15:41:32 -0400403 break;
404 }
405 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400406 spin_unlock(&root->fs_info->trans_lock);
Sage Weil46204592010-10-29 15:41:32 -0400407 if (!cur_trans)
Josef Bacika4abeea2011-04-11 17:25:13 -0400408 goto out; /* nothing committing|committed */
Sage Weil46204592010-10-29 15:41:32 -0400409 }
410
Sage Weil46204592010-10-29 15:41:32 -0400411 wait_for_commit(root, cur_trans);
412
Sage Weil46204592010-10-29 15:41:32 -0400413 put_transaction(cur_trans);
414 ret = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -0400415out:
Sage Weil46204592010-10-29 15:41:32 -0400416 return ret;
417}
418
Chris Mason37d1aee2008-07-31 10:48:37 -0400419void btrfs_throttle(struct btrfs_root *root)
420{
Josef Bacika4abeea2011-04-11 17:25:13 -0400421 if (!atomic_read(&root->fs_info->open_ioctl_trans))
Sage Weil9ca9ee02008-08-04 10:41:27 -0400422 wait_current_trans(root);
Chris Mason37d1aee2008-07-31 10:48:37 -0400423}
424
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400425static int should_end_transaction(struct btrfs_trans_handle *trans,
426 struct btrfs_root *root)
427{
428 int ret;
Josef Bacik36ba0222011-10-18 12:15:48 -0400429
430 ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400431 return ret ? 1 : 0;
432}
433
434int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
435 struct btrfs_root *root)
436{
437 struct btrfs_transaction *cur_trans = trans->transaction;
Josef Bacik9c8d86d2011-09-19 11:58:54 -0400438 struct btrfs_block_rsv *rsv = trans->block_rsv;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400439 int updates;
440
Josef Bacika4abeea2011-04-11 17:25:13 -0400441 smp_mb();
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400442 if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
443 return 1;
444
Josef Bacik9c8d86d2011-09-19 11:58:54 -0400445 /*
446 * We need to do this in case we're deleting csums so the global block
447 * rsv get's used instead of the csum block rsv.
448 */
449 trans->block_rsv = NULL;
450
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400451 updates = trans->delayed_ref_updates;
452 trans->delayed_ref_updates = 0;
453 if (updates)
454 btrfs_run_delayed_refs(trans, root, updates);
455
Josef Bacik9c8d86d2011-09-19 11:58:54 -0400456 trans->block_rsv = rsv;
457
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400458 return should_end_transaction(trans, root);
459}
460
Chris Mason89ce8a62008-06-25 16:01:31 -0400461static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
Josef Bacik0af3d002010-06-21 14:48:16 -0400462 struct btrfs_root *root, int throttle, int lock)
Chris Mason79154b12007-03-22 15:59:16 -0400463{
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400464 struct btrfs_transaction *cur_trans = trans->transaction;
Chris Masonab78c842008-07-29 16:15:18 -0400465 struct btrfs_fs_info *info = root->fs_info;
Chris Masonc3e69d52009-03-13 10:17:05 -0400466 int count = 0;
Chris Masond6e4a422007-04-06 15:37:36 -0400467
Josef Bacik2a1eb462011-04-13 15:15:59 -0400468 if (--trans->use_count) {
469 trans->block_rsv = trans->orig_rsv;
470 return 0;
471 }
472
Josef Bacikb24e03d2011-10-14 14:40:17 -0400473 btrfs_trans_release_metadata(trans, root);
Josef Bacik4c13d752011-08-30 11:31:29 -0400474 trans->block_rsv = NULL;
Chris Mason203bf282012-01-06 15:23:57 -0500475 while (count < 2) {
Chris Masonc3e69d52009-03-13 10:17:05 -0400476 unsigned long cur = trans->delayed_ref_updates;
477 trans->delayed_ref_updates = 0;
478 if (cur &&
479 trans->transaction->delayed_refs.num_heads_ready > 64) {
480 trans->delayed_ref_updates = 0;
481 btrfs_run_delayed_refs(trans, root, cur);
482 } else {
483 break;
484 }
485 count++;
Chris Mason56bec292009-03-13 10:10:06 -0400486 }
487
Josef Bacika4abeea2011-04-11 17:25:13 -0400488 if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
489 should_end_transaction(trans, root)) {
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400490 trans->transaction->blocked = 1;
Josef Bacika4abeea2011-04-11 17:25:13 -0400491 smp_wmb();
492 }
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400493
Josef Bacik0af3d002010-06-21 14:48:16 -0400494 if (lock && cur_trans->blocked && !cur_trans->in_commit) {
Josef Bacik81317fd2011-07-24 15:45:34 -0400495 if (throttle) {
496 /*
497 * We may race with somebody else here so end up having
498 * to call end_transaction on ourselves again, so inc
499 * our use_count.
500 */
501 trans->use_count++;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400502 return btrfs_commit_transaction(trans, root);
Josef Bacik81317fd2011-07-24 15:45:34 -0400503 } else {
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400504 wake_up_process(info->transaction_kthread);
Josef Bacik81317fd2011-07-24 15:45:34 -0400505 }
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400506 }
507
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400508 WARN_ON(cur_trans != info->running_transaction);
Josef Bacik13c5a932011-04-11 15:45:29 -0400509 WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
510 atomic_dec(&cur_trans->num_writers);
Chris Mason89ce8a62008-06-25 16:01:31 -0400511
Sage Weil99d16cb2010-10-29 15:37:34 -0400512 smp_mb();
Chris Mason79154b12007-03-22 15:59:16 -0400513 if (waitqueue_active(&cur_trans->writer_wait))
514 wake_up(&cur_trans->writer_wait);
Chris Mason79154b12007-03-22 15:59:16 -0400515 put_transaction(cur_trans);
Josef Bacik9ed74f22009-09-11 16:12:44 -0400516
517 if (current->journal_info == trans)
518 current->journal_info = NULL;
Chris Masond6025572007-03-30 14:27:56 -0400519 memset(trans, 0, sizeof(*trans));
Chris Mason2c90e5d2007-04-02 10:50:19 -0400520 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Chris Masonab78c842008-07-29 16:15:18 -0400521
Yan, Zheng24bbcf042009-11-12 09:36:34 +0000522 if (throttle)
523 btrfs_run_delayed_iputs(root);
524
Chris Mason79154b12007-03-22 15:59:16 -0400525 return 0;
526}
527
Chris Mason89ce8a62008-06-25 16:01:31 -0400528int btrfs_end_transaction(struct btrfs_trans_handle *trans,
529 struct btrfs_root *root)
530{
Miao Xie16cdcec2011-04-22 18:12:22 +0800531 int ret;
532
533 ret = __btrfs_end_transaction(trans, root, 0, 1);
534 if (ret)
535 return ret;
536 return 0;
Chris Mason89ce8a62008-06-25 16:01:31 -0400537}
538
539int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
540 struct btrfs_root *root)
541{
Miao Xie16cdcec2011-04-22 18:12:22 +0800542 int ret;
543
544 ret = __btrfs_end_transaction(trans, root, 1, 1);
545 if (ret)
546 return ret;
547 return 0;
Josef Bacik0af3d002010-06-21 14:48:16 -0400548}
549
550int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
551 struct btrfs_root *root)
552{
Miao Xie16cdcec2011-04-22 18:12:22 +0800553 int ret;
554
555 ret = __btrfs_end_transaction(trans, root, 0, 0);
556 if (ret)
557 return ret;
558 return 0;
559}
560
561int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans,
562 struct btrfs_root *root)
563{
564 return __btrfs_end_transaction(trans, root, 1, 1);
Chris Mason89ce8a62008-06-25 16:01:31 -0400565}
566
Chris Masond352ac62008-09-29 15:18:18 -0400567/*
568 * when btree blocks are allocated, they have some corresponding bits set for
569 * them in one of two extent_io trees. This is used to make sure all of
Chris Mason690587d2009-10-13 13:29:19 -0400570 * those extents are sent to disk but does not wait on them
Chris Masond352ac62008-09-29 15:18:18 -0400571 */
Chris Mason690587d2009-10-13 13:29:19 -0400572int btrfs_write_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000573 struct extent_io_tree *dirty_pages, int mark)
Chris Mason79154b12007-03-22 15:59:16 -0400574{
Chris Mason777e6bd2008-08-15 15:34:15 -0400575 int err = 0;
Chris Mason7c4452b2007-04-28 09:29:35 -0400576 int werr = 0;
Josef Bacik17283662011-09-26 13:58:47 -0400577 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
Chris Mason777e6bd2008-08-15 15:34:15 -0400578 u64 start = 0;
Chris Mason5f39d392007-10-15 16:14:19 -0400579 u64 end;
Chris Mason7c4452b2007-04-28 09:29:35 -0400580
Josef Bacik17283662011-09-26 13:58:47 -0400581 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
582 mark)) {
583 convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT, mark,
584 GFP_NOFS);
585 err = filemap_fdatawrite_range(mapping, start, end);
586 if (err)
587 werr = err;
588 cond_resched();
589 start = end + 1;
Chris Mason7c4452b2007-04-28 09:29:35 -0400590 }
Chris Mason690587d2009-10-13 13:29:19 -0400591 if (err)
592 werr = err;
593 return werr;
594}
595
596/*
597 * when btree blocks are allocated, they have some corresponding bits set for
598 * them in one of two extent_io trees. This is used to make sure all of
599 * those extents are on disk for transaction or log commit. We wait
600 * on all the pages and clear them from the dirty pages state tree
601 */
602int btrfs_wait_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000603 struct extent_io_tree *dirty_pages, int mark)
Chris Mason690587d2009-10-13 13:29:19 -0400604{
Chris Mason690587d2009-10-13 13:29:19 -0400605 int err = 0;
606 int werr = 0;
Josef Bacik17283662011-09-26 13:58:47 -0400607 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
Chris Mason690587d2009-10-13 13:29:19 -0400608 u64 start = 0;
609 u64 end;
Chris Mason690587d2009-10-13 13:29:19 -0400610
Josef Bacik17283662011-09-26 13:58:47 -0400611 while (!find_first_extent_bit(dirty_pages, start, &start, &end,
612 EXTENT_NEED_WAIT)) {
613 clear_extent_bits(dirty_pages, start, end, EXTENT_NEED_WAIT, GFP_NOFS);
614 err = filemap_fdatawait_range(mapping, start, end);
615 if (err)
616 werr = err;
617 cond_resched();
618 start = end + 1;
Chris Mason777e6bd2008-08-15 15:34:15 -0400619 }
Chris Mason7c4452b2007-04-28 09:29:35 -0400620 if (err)
621 werr = err;
622 return werr;
Chris Mason79154b12007-03-22 15:59:16 -0400623}
624
Chris Mason690587d2009-10-13 13:29:19 -0400625/*
626 * when btree blocks are allocated, they have some corresponding bits set for
627 * them in one of two extent_io trees. This is used to make sure all of
628 * those extents are on disk for transaction or log commit
629 */
630int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000631 struct extent_io_tree *dirty_pages, int mark)
Chris Mason690587d2009-10-13 13:29:19 -0400632{
633 int ret;
634 int ret2;
635
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000636 ret = btrfs_write_marked_extents(root, dirty_pages, mark);
637 ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
Chris Masonbf0da8c2011-11-04 12:29:37 -0400638
639 if (ret)
640 return ret;
641 if (ret2)
642 return ret2;
643 return 0;
Chris Mason690587d2009-10-13 13:29:19 -0400644}
645
Chris Masond0c803c2008-09-11 16:17:57 -0400646int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
647 struct btrfs_root *root)
648{
649 if (!trans || !trans->transaction) {
650 struct inode *btree_inode;
651 btree_inode = root->fs_info->btree_inode;
652 return filemap_write_and_wait(btree_inode->i_mapping);
653 }
654 return btrfs_write_and_wait_marked_extents(root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000655 &trans->transaction->dirty_pages,
656 EXTENT_DIRTY);
Chris Masond0c803c2008-09-11 16:17:57 -0400657}
658
Chris Masond352ac62008-09-29 15:18:18 -0400659/*
660 * this is used to update the root pointer in the tree of tree roots.
661 *
662 * But, in the case of the extent allocation tree, updating the root
663 * pointer may allocate blocks which may change the root of the extent
664 * allocation tree.
665 *
666 * So, this loops and repeats and makes sure the cowonly root didn't
667 * change while the root pointer was being updated in the metadata.
668 */
Chris Mason0b86a832008-03-24 15:01:56 -0400669static int update_cowonly_root(struct btrfs_trans_handle *trans,
670 struct btrfs_root *root)
671{
672 int ret;
673 u64 old_root_bytenr;
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000674 u64 old_root_used;
Chris Mason0b86a832008-03-24 15:01:56 -0400675 struct btrfs_root *tree_root = root->fs_info->tree_root;
676
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000677 old_root_used = btrfs_root_used(&root->root_item);
Chris Mason0b86a832008-03-24 15:01:56 -0400678 btrfs_write_dirty_block_groups(trans, root);
Chris Mason56bec292009-03-13 10:10:06 -0400679
Chris Masond3977122009-01-05 21:25:51 -0500680 while (1) {
Chris Mason0b86a832008-03-24 15:01:56 -0400681 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000682 if (old_root_bytenr == root->node->start &&
683 old_root_used == btrfs_root_used(&root->root_item))
Chris Mason0b86a832008-03-24 15:01:56 -0400684 break;
Chris Mason87ef2bb2008-10-30 11:23:27 -0400685
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400686 btrfs_set_root_node(&root->root_item, root->node);
Chris Mason0b86a832008-03-24 15:01:56 -0400687 ret = btrfs_update_root(trans, tree_root,
688 &root->root_key,
689 &root->root_item);
690 BUG_ON(ret);
Chris Mason56bec292009-03-13 10:10:06 -0400691
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000692 old_root_used = btrfs_root_used(&root->root_item);
Yan Zheng4a8c9a62009-07-22 10:07:05 -0400693 ret = btrfs_write_dirty_block_groups(trans, root);
Chris Mason56bec292009-03-13 10:10:06 -0400694 BUG_ON(ret);
Chris Mason0b86a832008-03-24 15:01:56 -0400695 }
Yan Zheng276e6802009-07-30 09:40:40 -0400696
697 if (root != root->fs_info->extent_root)
698 switch_commit_root(root);
699
Chris Mason0b86a832008-03-24 15:01:56 -0400700 return 0;
701}
702
Chris Masond352ac62008-09-29 15:18:18 -0400703/*
704 * update all the cowonly tree roots on disk
705 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400706static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
707 struct btrfs_root *root)
Chris Mason79154b12007-03-22 15:59:16 -0400708{
Chris Mason79154b12007-03-22 15:59:16 -0400709 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Mason0b86a832008-03-24 15:01:56 -0400710 struct list_head *next;
Yan Zheng84234f32008-10-29 14:49:05 -0400711 struct extent_buffer *eb;
Chris Mason56bec292009-03-13 10:10:06 -0400712 int ret;
Yan Zheng84234f32008-10-29 14:49:05 -0400713
Chris Mason56bec292009-03-13 10:10:06 -0400714 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
715 BUG_ON(ret);
Chris Mason87ef2bb2008-10-30 11:23:27 -0400716
Yan Zheng84234f32008-10-29 14:49:05 -0400717 eb = btrfs_lock_root_node(fs_info->tree_root);
Chris Mason9fa8cfe2009-03-13 10:24:59 -0400718 btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
Yan Zheng84234f32008-10-29 14:49:05 -0400719 btrfs_tree_unlock(eb);
720 free_extent_buffer(eb);
Chris Mason79154b12007-03-22 15:59:16 -0400721
Chris Mason56bec292009-03-13 10:10:06 -0400722 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
723 BUG_ON(ret);
Chris Mason87ef2bb2008-10-30 11:23:27 -0400724
Chris Masond3977122009-01-05 21:25:51 -0500725 while (!list_empty(&fs_info->dirty_cowonly_roots)) {
Chris Mason0b86a832008-03-24 15:01:56 -0400726 next = fs_info->dirty_cowonly_roots.next;
727 list_del_init(next);
728 root = list_entry(next, struct btrfs_root, dirty_list);
Chris Mason87ef2bb2008-10-30 11:23:27 -0400729
Chris Mason0b86a832008-03-24 15:01:56 -0400730 update_cowonly_root(trans, root);
Chris Mason79154b12007-03-22 15:59:16 -0400731 }
Yan Zheng276e6802009-07-30 09:40:40 -0400732
733 down_write(&fs_info->extent_commit_sem);
734 switch_commit_root(fs_info->extent_root);
735 up_write(&fs_info->extent_commit_sem);
736
Chris Mason79154b12007-03-22 15:59:16 -0400737 return 0;
738}
739
Chris Masond352ac62008-09-29 15:18:18 -0400740/*
741 * dead roots are old snapshots that need to be deleted. This allocates
742 * a dirty root struct and adds it into the list of dead roots that need to
743 * be deleted
744 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400745int btrfs_add_dead_root(struct btrfs_root *root)
Chris Mason5eda7b52007-06-22 14:16:25 -0400746{
Josef Bacika4abeea2011-04-11 17:25:13 -0400747 spin_lock(&root->fs_info->trans_lock);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400748 list_add(&root->root_list, &root->fs_info->dead_roots);
Josef Bacika4abeea2011-04-11 17:25:13 -0400749 spin_unlock(&root->fs_info->trans_lock);
Chris Mason5eda7b52007-06-22 14:16:25 -0400750 return 0;
751}
752
Chris Masond352ac62008-09-29 15:18:18 -0400753/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400754 * update all the cowonly tree roots on disk
Chris Masond352ac62008-09-29 15:18:18 -0400755 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400756static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
757 struct btrfs_root *root)
Chris Mason0f7d52f2007-04-09 10:42:37 -0400758{
Chris Mason0f7d52f2007-04-09 10:42:37 -0400759 struct btrfs_root *gang[8];
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400760 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400761 int i;
762 int ret;
Chris Mason54aa1f42007-06-22 14:16:25 -0400763 int err = 0;
764
Josef Bacika4abeea2011-04-11 17:25:13 -0400765 spin_lock(&fs_info->fs_roots_radix_lock);
Chris Masond3977122009-01-05 21:25:51 -0500766 while (1) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400767 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
768 (void **)gang, 0,
Chris Mason0f7d52f2007-04-09 10:42:37 -0400769 ARRAY_SIZE(gang),
770 BTRFS_ROOT_TRANS_TAG);
771 if (ret == 0)
772 break;
773 for (i = 0; i < ret; i++) {
774 root = gang[i];
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400775 radix_tree_tag_clear(&fs_info->fs_roots_radix,
776 (unsigned long)root->root_key.objectid,
777 BTRFS_ROOT_TRANS_TAG);
Josef Bacika4abeea2011-04-11 17:25:13 -0400778 spin_unlock(&fs_info->fs_roots_radix_lock);
Yan Zheng31153d82008-07-28 15:32:19 -0400779
Chris Masone02119d2008-09-05 16:13:11 -0400780 btrfs_free_log(trans, root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400781 btrfs_update_reloc_root(trans, root);
Yan, Zhengd68fc572010-05-16 10:49:58 -0400782 btrfs_orphan_commit_root(trans, root);
Chris Masone02119d2008-09-05 16:13:11 -0400783
Li Zefan82d59022011-04-20 10:33:24 +0800784 btrfs_save_ino_cache(root, trans);
785
Liu Bof1ebcc72011-11-14 20:48:06 -0500786 /* see comments in should_cow_block() */
787 root->force_cow = 0;
788 smp_wmb();
789
Yan Zheng978d9102009-06-15 20:01:02 -0400790 if (root->commit_root != root->node) {
Li Zefan581bb052011-04-20 10:06:11 +0800791 mutex_lock(&root->fs_commit_mutex);
Josef Bacik817d52f2009-07-13 21:29:25 -0400792 switch_commit_root(root);
Li Zefan581bb052011-04-20 10:06:11 +0800793 btrfs_unpin_free_ino(root);
794 mutex_unlock(&root->fs_commit_mutex);
795
Yan Zheng978d9102009-06-15 20:01:02 -0400796 btrfs_set_root_node(&root->root_item,
797 root->node);
798 }
Chris Mason9f3a7422007-08-07 15:52:19 -0400799
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400800 err = btrfs_update_root(trans, fs_info->tree_root,
Chris Mason0f7d52f2007-04-09 10:42:37 -0400801 &root->root_key,
802 &root->root_item);
Josef Bacika4abeea2011-04-11 17:25:13 -0400803 spin_lock(&fs_info->fs_roots_radix_lock);
Chris Mason54aa1f42007-06-22 14:16:25 -0400804 if (err)
805 break;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400806 }
807 }
Josef Bacika4abeea2011-04-11 17:25:13 -0400808 spin_unlock(&fs_info->fs_roots_radix_lock);
Chris Mason54aa1f42007-06-22 14:16:25 -0400809 return err;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400810}
811
Chris Masond352ac62008-09-29 15:18:18 -0400812/*
813 * defrag a given btree. If cacheonly == 1, this won't read from the disk,
814 * otherwise every leaf in the btree is read and defragged.
815 */
Chris Masone9d0b132007-08-10 14:06:19 -0400816int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
817{
818 struct btrfs_fs_info *info = root->fs_info;
Chris Masone9d0b132007-08-10 14:06:19 -0400819 struct btrfs_trans_handle *trans;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400820 int ret;
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400821 unsigned long nr;
Chris Masone9d0b132007-08-10 14:06:19 -0400822
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400823 if (xchg(&root->defrag_running, 1))
Chris Masone9d0b132007-08-10 14:06:19 -0400824 return 0;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400825
Chris Mason6b800532007-10-15 16:17:34 -0400826 while (1) {
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400827 trans = btrfs_start_transaction(root, 0);
828 if (IS_ERR(trans))
829 return PTR_ERR(trans);
830
Chris Masone9d0b132007-08-10 14:06:19 -0400831 ret = btrfs_defrag_leaves(trans, root, cacheonly);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400832
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400833 nr = trans->blocks_used;
Chris Masone9d0b132007-08-10 14:06:19 -0400834 btrfs_end_transaction(trans, root);
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400835 btrfs_btree_balance_dirty(info->tree_root, nr);
Chris Masone9d0b132007-08-10 14:06:19 -0400836 cond_resched();
837
David Sterba7841cb22011-05-31 18:07:27 +0200838 if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
Chris Masone9d0b132007-08-10 14:06:19 -0400839 break;
840 }
841 root->defrag_running = 0;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400842 return ret;
Chris Masone9d0b132007-08-10 14:06:19 -0400843}
844
Chris Masond352ac62008-09-29 15:18:18 -0400845/*
846 * new snapshots need to be created at a very specific time in the
847 * transaction commit. This does the actual creation
848 */
Chris Mason80b67942008-02-01 16:35:04 -0500849static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
Chris Mason3063d292008-01-08 15:46:30 -0500850 struct btrfs_fs_info *fs_info,
851 struct btrfs_pending_snapshot *pending)
852{
853 struct btrfs_key key;
Chris Mason80b67942008-02-01 16:35:04 -0500854 struct btrfs_root_item *new_root_item;
Chris Mason3063d292008-01-08 15:46:30 -0500855 struct btrfs_root *tree_root = fs_info->tree_root;
856 struct btrfs_root *root = pending->root;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000857 struct btrfs_root *parent_root;
Liu Bo98c99422011-09-11 10:52:24 -0400858 struct btrfs_block_rsv *rsv;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000859 struct inode *parent_inode;
Josef Bacik6a912212010-11-20 09:48:00 +0000860 struct dentry *parent;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400861 struct dentry *dentry;
Chris Mason3063d292008-01-08 15:46:30 -0500862 struct extent_buffer *tmp;
Chris Mason925baed2008-06-25 16:01:30 -0400863 struct extent_buffer *old;
Chris Mason3063d292008-01-08 15:46:30 -0500864 int ret;
Yan, Zhengd68fc572010-05-16 10:49:58 -0400865 u64 to_reserve = 0;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000866 u64 index = 0;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400867 u64 objectid;
Li Zefanb83cc962010-12-20 16:04:08 +0800868 u64 root_flags;
Chris Mason3063d292008-01-08 15:46:30 -0500869
Liu Bo98c99422011-09-11 10:52:24 -0400870 rsv = trans->block_rsv;
871
Chris Mason80b67942008-02-01 16:35:04 -0500872 new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
873 if (!new_root_item) {
Yan, Zhenga22285a2010-05-16 10:48:46 -0400874 pending->error = -ENOMEM;
Chris Mason80b67942008-02-01 16:35:04 -0500875 goto fail;
876 }
Yan, Zhenga22285a2010-05-16 10:48:46 -0400877
Li Zefan581bb052011-04-20 10:06:11 +0800878 ret = btrfs_find_free_objectid(tree_root, &objectid);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400879 if (ret) {
880 pending->error = ret;
Chris Mason3063d292008-01-08 15:46:30 -0500881 goto fail;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400882 }
Chris Mason3063d292008-01-08 15:46:30 -0500883
Yan, Zheng3fd0a552010-05-16 10:49:59 -0400884 btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
Yan, Zhengd68fc572010-05-16 10:49:58 -0400885
886 if (to_reserve > 0) {
Miao Xie62f30c52011-11-10 20:45:05 -0500887 ret = btrfs_block_rsv_add_noflush(root, &pending->block_rsv,
888 to_reserve);
Yan, Zhengd68fc572010-05-16 10:49:58 -0400889 if (ret) {
890 pending->error = ret;
891 goto fail;
892 }
893 }
894
Chris Mason3063d292008-01-08 15:46:30 -0500895 key.objectid = objectid;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400896 key.offset = (u64)-1;
897 key.type = BTRFS_ROOT_ITEM_KEY;
Chris Mason3063d292008-01-08 15:46:30 -0500898
Yan, Zhenga22285a2010-05-16 10:48:46 -0400899 trans->block_rsv = &pending->block_rsv;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000900
Yan, Zhenga22285a2010-05-16 10:48:46 -0400901 dentry = pending->dentry;
Josef Bacik6a912212010-11-20 09:48:00 +0000902 parent = dget_parent(dentry);
903 parent_inode = parent->d_inode;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400904 parent_root = BTRFS_I(parent_inode)->root;
Chris Mason75857172011-06-13 20:00:16 -0400905 record_root_in_trans(trans, parent_root);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400906
Sage Weil6bdb72d2010-03-15 17:27:13 +0000907 /*
908 * insert the directory item
909 */
Sage Weil6bdb72d2010-03-15 17:27:13 +0000910 ret = btrfs_set_inode_index(parent_inode, &index);
911 BUG_ON(ret);
912 ret = btrfs_insert_dir_item(trans, parent_root,
Yan, Zhenga22285a2010-05-16 10:48:46 -0400913 dentry->d_name.name, dentry->d_name.len,
Miao Xie16cdcec2011-04-22 18:12:22 +0800914 parent_inode, &key,
Yan, Zhenga22285a2010-05-16 10:48:46 -0400915 BTRFS_FT_DIR, index);
Sage Weil6bdb72d2010-03-15 17:27:13 +0000916 BUG_ON(ret);
917
Yan, Zhenga22285a2010-05-16 10:48:46 -0400918 btrfs_i_size_write(parent_inode, parent_inode->i_size +
919 dentry->d_name.len * 2);
Sage Weil6bdb72d2010-03-15 17:27:13 +0000920 ret = btrfs_update_inode(trans, parent_root, parent_inode);
921 BUG_ON(ret);
922
Chris Masone9993762011-06-17 16:14:09 -0400923 /*
924 * pull in the delayed directory update
925 * and the delayed inode item
926 * otherwise we corrupt the FS during
927 * snapshot
928 */
929 ret = btrfs_run_delayed_items(trans, root);
930 BUG_ON(ret);
931
Chris Mason75857172011-06-13 20:00:16 -0400932 record_root_in_trans(trans, root);
Sage Weil6bdb72d2010-03-15 17:27:13 +0000933 btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
934 memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
Li Zefan08fe4db2011-03-28 02:01:25 +0000935 btrfs_check_and_init_root_item(new_root_item);
Sage Weil6bdb72d2010-03-15 17:27:13 +0000936
Li Zefanb83cc962010-12-20 16:04:08 +0800937 root_flags = btrfs_root_flags(new_root_item);
938 if (pending->readonly)
939 root_flags |= BTRFS_ROOT_SUBVOL_RDONLY;
940 else
941 root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY;
942 btrfs_set_root_flags(new_root_item, root_flags);
943
Chris Mason925baed2008-06-25 16:01:30 -0400944 old = btrfs_lock_root_node(root);
Chris Mason9fa8cfe2009-03-13 10:24:59 -0400945 btrfs_cow_block(trans, root, old, NULL, 0, &old);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400946 btrfs_set_lock_blocking(old);
Chris Mason3063d292008-01-08 15:46:30 -0500947
Chris Mason925baed2008-06-25 16:01:30 -0400948 btrfs_copy_root(trans, root, old, &tmp, objectid);
949 btrfs_tree_unlock(old);
950 free_extent_buffer(old);
Chris Mason3063d292008-01-08 15:46:30 -0500951
Liu Bof1ebcc72011-11-14 20:48:06 -0500952 /* see comments in should_cow_block() */
953 root->force_cow = 1;
954 smp_wmb();
955
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400956 btrfs_set_root_node(new_root_item, tmp);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400957 /* record when the snapshot was created in key.offset */
958 key.offset = trans->transid;
959 ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
Chris Mason925baed2008-06-25 16:01:30 -0400960 btrfs_tree_unlock(tmp);
Chris Mason3063d292008-01-08 15:46:30 -0500961 free_extent_buffer(tmp);
Chris Mason0660b5a2008-11-17 20:37:39 -0500962 BUG_ON(ret);
963
Yan, Zhenga22285a2010-05-16 10:48:46 -0400964 /*
965 * insert root back/forward references
966 */
967 ret = btrfs_add_root_ref(trans, tree_root, objectid,
968 parent_root->root_key.objectid,
Li Zefan33345d012011-04-20 10:31:50 +0800969 btrfs_ino(parent_inode), index,
Yan, Zhenga22285a2010-05-16 10:48:46 -0400970 dentry->d_name.name, dentry->d_name.len);
971 BUG_ON(ret);
Josef Bacik6a912212010-11-20 09:48:00 +0000972 dput(parent);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400973
974 key.offset = (u64)-1;
975 pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
976 BUG_ON(IS_ERR(pending->snap));
Yan, Zhengd68fc572010-05-16 10:49:58 -0400977
Yan, Zheng3fd0a552010-05-16 10:49:59 -0400978 btrfs_reloc_post_snapshot(trans, pending);
Chris Mason3063d292008-01-08 15:46:30 -0500979fail:
Sage Weil6bdb72d2010-03-15 17:27:13 +0000980 kfree(new_root_item);
Liu Bo98c99422011-09-11 10:52:24 -0400981 trans->block_rsv = rsv;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400982 btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
983 return 0;
Chris Mason3063d292008-01-08 15:46:30 -0500984}
985
Chris Masond352ac62008-09-29 15:18:18 -0400986/*
987 * create all the snapshots we've scheduled for creation
988 */
Chris Mason80b67942008-02-01 16:35:04 -0500989static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
990 struct btrfs_fs_info *fs_info)
Chris Mason3063d292008-01-08 15:46:30 -0500991{
992 struct btrfs_pending_snapshot *pending;
993 struct list_head *head = &trans->transaction->pending_snapshots;
Chris Mason3de45862008-11-17 21:02:50 -0500994 int ret;
995
Qinghuang Fengc6e30872009-01-21 10:59:08 -0500996 list_for_each_entry(pending, head, list) {
Chris Mason3de45862008-11-17 21:02:50 -0500997 ret = create_pending_snapshot(trans, fs_info, pending);
998 BUG_ON(ret);
999 }
1000 return 0;
1001}
1002
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001003static void update_super_roots(struct btrfs_root *root)
1004{
1005 struct btrfs_root_item *root_item;
1006 struct btrfs_super_block *super;
1007
David Sterba6c417612011-04-13 15:41:04 +02001008 super = root->fs_info->super_copy;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001009
1010 root_item = &root->fs_info->chunk_root->root_item;
1011 super->chunk_root = root_item->bytenr;
1012 super->chunk_root_generation = root_item->generation;
1013 super->chunk_root_level = root_item->level;
1014
1015 root_item = &root->fs_info->tree_root->root_item;
1016 super->root = root_item->bytenr;
1017 super->generation = root_item->generation;
1018 super->root_level = root_item->level;
Josef Bacik73bc1872011-10-03 14:07:49 -04001019 if (btrfs_test_opt(root, SPACE_CACHE))
Josef Bacik0af3d002010-06-21 14:48:16 -04001020 super->cache_generation = root_item->generation;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001021}
1022
Chris Masonf36f3042009-07-30 10:04:48 -04001023int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
1024{
1025 int ret = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -04001026 spin_lock(&info->trans_lock);
Chris Masonf36f3042009-07-30 10:04:48 -04001027 if (info->running_transaction)
1028 ret = info->running_transaction->in_commit;
Josef Bacika4abeea2011-04-11 17:25:13 -04001029 spin_unlock(&info->trans_lock);
Chris Masonf36f3042009-07-30 10:04:48 -04001030 return ret;
1031}
1032
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001033int btrfs_transaction_blocked(struct btrfs_fs_info *info)
1034{
1035 int ret = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -04001036 spin_lock(&info->trans_lock);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001037 if (info->running_transaction)
1038 ret = info->running_transaction->blocked;
Josef Bacika4abeea2011-04-11 17:25:13 -04001039 spin_unlock(&info->trans_lock);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001040 return ret;
1041}
1042
Sage Weilbb9c12c2010-10-29 15:37:34 -04001043/*
1044 * wait for the current transaction commit to start and block subsequent
1045 * transaction joins
1046 */
1047static void wait_current_trans_commit_start(struct btrfs_root *root,
1048 struct btrfs_transaction *trans)
1049{
Li Zefan72d63ed2011-07-14 03:17:00 +00001050 wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001051}
1052
1053/*
1054 * wait for the current transaction to start and then become unblocked.
1055 * caller holds ref.
1056 */
1057static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root,
1058 struct btrfs_transaction *trans)
1059{
Li Zefan72d63ed2011-07-14 03:17:00 +00001060 wait_event(root->fs_info->transaction_wait,
1061 trans->commit_done || (trans->in_commit && !trans->blocked));
Sage Weilbb9c12c2010-10-29 15:37:34 -04001062}
1063
1064/*
1065 * commit transactions asynchronously. once btrfs_commit_transaction_async
1066 * returns, any subsequent transaction will not be allowed to join.
1067 */
1068struct btrfs_async_commit {
1069 struct btrfs_trans_handle *newtrans;
1070 struct btrfs_root *root;
1071 struct delayed_work work;
1072};
1073
1074static void do_async_commit(struct work_struct *work)
1075{
1076 struct btrfs_async_commit *ac =
1077 container_of(work, struct btrfs_async_commit, work.work);
1078
1079 btrfs_commit_transaction(ac->newtrans, ac->root);
1080 kfree(ac);
1081}
1082
1083int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
1084 struct btrfs_root *root,
1085 int wait_for_unblock)
1086{
1087 struct btrfs_async_commit *ac;
1088 struct btrfs_transaction *cur_trans;
1089
1090 ac = kmalloc(sizeof(*ac), GFP_NOFS);
Tsutomu Itohdb5b4932011-03-23 08:14:16 +00001091 if (!ac)
1092 return -ENOMEM;
Sage Weilbb9c12c2010-10-29 15:37:34 -04001093
1094 INIT_DELAYED_WORK(&ac->work, do_async_commit);
1095 ac->root = root;
Josef Bacik7a7eaa42011-04-13 12:54:33 -04001096 ac->newtrans = btrfs_join_transaction(root);
Tsutomu Itoh3612b492011-01-25 02:51:38 +00001097 if (IS_ERR(ac->newtrans)) {
1098 int err = PTR_ERR(ac->newtrans);
1099 kfree(ac);
1100 return err;
1101 }
Sage Weilbb9c12c2010-10-29 15:37:34 -04001102
1103 /* take transaction reference */
Sage Weilbb9c12c2010-10-29 15:37:34 -04001104 cur_trans = trans->transaction;
Josef Bacik13c5a932011-04-11 15:45:29 -04001105 atomic_inc(&cur_trans->use_count);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001106
1107 btrfs_end_transaction(trans, root);
1108 schedule_delayed_work(&ac->work, 0);
1109
1110 /* wait for transaction to start and unblock */
Sage Weilbb9c12c2010-10-29 15:37:34 -04001111 if (wait_for_unblock)
1112 wait_current_trans_commit_start_and_unblock(root, cur_trans);
1113 else
1114 wait_current_trans_commit_start(root, cur_trans);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001115
Sage Weil38e88052011-06-10 18:43:13 +00001116 if (current->journal_info == trans)
1117 current->journal_info = NULL;
1118
1119 put_transaction(cur_trans);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001120 return 0;
1121}
1122
1123/*
1124 * btrfs_transaction state sequence:
1125 * in_commit = 0, blocked = 0 (initial)
1126 * in_commit = 1, blocked = 1
1127 * blocked = 0
1128 * commit_done = 1
1129 */
Chris Mason79154b12007-03-22 15:59:16 -04001130int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
1131 struct btrfs_root *root)
1132{
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001133 unsigned long joined = 0;
Chris Mason79154b12007-03-22 15:59:16 -04001134 struct btrfs_transaction *cur_trans;
Chris Mason8fd17792007-04-19 21:01:03 -04001135 struct btrfs_transaction *prev_trans = NULL;
Chris Mason79154b12007-03-22 15:59:16 -04001136 DEFINE_WAIT(wait);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001137 int ret;
Chris Mason89573b92009-03-12 20:12:45 -04001138 int should_grow = 0;
1139 unsigned long now = get_seconds();
Sage Weildccae992009-04-02 16:59:01 -04001140 int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
Chris Mason79154b12007-03-22 15:59:16 -04001141
Chris Mason5a3f23d2009-03-31 13:27:11 -04001142 btrfs_run_ordered_operations(root, 0);
1143
Josef Bacikb24e03d2011-10-14 14:40:17 -04001144 btrfs_trans_release_metadata(trans, root);
Josef Bacik9c8d86d2011-09-19 11:58:54 -04001145 trans->block_rsv = NULL;
1146
Chris Mason56bec292009-03-13 10:10:06 -04001147 /* make a pass through all the delayed refs we have so far
1148 * any runnings procs may add more while we are here
1149 */
1150 ret = btrfs_run_delayed_refs(trans, root, 0);
1151 BUG_ON(ret);
1152
Chris Masonb7ec40d2009-03-12 20:12:45 -04001153 cur_trans = trans->transaction;
Chris Mason56bec292009-03-13 10:10:06 -04001154 /*
1155 * set the flushing flag so procs in this transaction have to
1156 * start sending their work down.
1157 */
Chris Masonb7ec40d2009-03-12 20:12:45 -04001158 cur_trans->delayed_refs.flushing = 1;
Chris Mason56bec292009-03-13 10:10:06 -04001159
Chris Masonc3e69d52009-03-13 10:17:05 -04001160 ret = btrfs_run_delayed_refs(trans, root, 0);
Chris Mason56bec292009-03-13 10:10:06 -04001161 BUG_ON(ret);
1162
Josef Bacika4abeea2011-04-11 17:25:13 -04001163 spin_lock(&cur_trans->commit_lock);
Chris Masonb7ec40d2009-03-12 20:12:45 -04001164 if (cur_trans->in_commit) {
Josef Bacika4abeea2011-04-11 17:25:13 -04001165 spin_unlock(&cur_trans->commit_lock);
Josef Bacik13c5a932011-04-11 15:45:29 -04001166 atomic_inc(&cur_trans->use_count);
Chris Mason79154b12007-03-22 15:59:16 -04001167 btrfs_end_transaction(trans, root);
Chris Masonccd467d2007-06-28 15:57:36 -04001168
Li Zefanb9c83002011-07-14 03:17:14 +00001169 wait_for_commit(root, cur_trans);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001170
Chris Mason79154b12007-03-22 15:59:16 -04001171 put_transaction(cur_trans);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001172
Chris Mason79154b12007-03-22 15:59:16 -04001173 return 0;
1174 }
Chris Mason4313b392008-01-03 09:08:48 -05001175
Chris Mason2c90e5d2007-04-02 10:50:19 -04001176 trans->transaction->in_commit = 1;
Chris Masonf9295742008-07-17 12:54:14 -04001177 trans->transaction->blocked = 1;
Josef Bacika4abeea2011-04-11 17:25:13 -04001178 spin_unlock(&cur_trans->commit_lock);
Sage Weilbb9c12c2010-10-29 15:37:34 -04001179 wake_up(&root->fs_info->transaction_blocked_wait);
1180
Josef Bacika4abeea2011-04-11 17:25:13 -04001181 spin_lock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001182 if (cur_trans->list.prev != &root->fs_info->trans_list) {
1183 prev_trans = list_entry(cur_trans->list.prev,
1184 struct btrfs_transaction, list);
1185 if (!prev_trans->commit_done) {
Josef Bacik13c5a932011-04-11 15:45:29 -04001186 atomic_inc(&prev_trans->use_count);
Josef Bacika4abeea2011-04-11 17:25:13 -04001187 spin_unlock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001188
1189 wait_for_commit(root, prev_trans);
Chris Masonccd467d2007-06-28 15:57:36 -04001190
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001191 put_transaction(prev_trans);
Josef Bacika4abeea2011-04-11 17:25:13 -04001192 } else {
1193 spin_unlock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001194 }
Josef Bacika4abeea2011-04-11 17:25:13 -04001195 } else {
1196 spin_unlock(&root->fs_info->trans_lock);
Chris Masonccd467d2007-06-28 15:57:36 -04001197 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001198
Chris Mason89573b92009-03-12 20:12:45 -04001199 if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
1200 should_grow = 1;
1201
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001202 do {
Yan Zheng7ea394f2008-08-05 13:05:02 -04001203 int snap_pending = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -04001204
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001205 joined = cur_trans->num_joined;
Yan Zheng7ea394f2008-08-05 13:05:02 -04001206 if (!list_empty(&trans->transaction->pending_snapshots))
1207 snap_pending = 1;
1208
Chris Mason2c90e5d2007-04-02 10:50:19 -04001209 WARN_ON(cur_trans != trans->transaction);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001210
Sage Weil0bdb1db2010-02-19 14:13:50 -08001211 if (flush_on_commit || snap_pending) {
Yan, Zheng24bbcf042009-11-12 09:36:34 +00001212 btrfs_start_delalloc_inodes(root, 1);
1213 ret = btrfs_wait_ordered_extents(root, 0, 1);
Sage Weilebecd3d2009-07-24 13:17:44 -04001214 BUG_ON(ret);
Yan Zheng7ea394f2008-08-05 13:05:02 -04001215 }
1216
Miao Xie16cdcec2011-04-22 18:12:22 +08001217 ret = btrfs_run_delayed_items(trans, root);
1218 BUG_ON(ret);
1219
Chris Mason5a3f23d2009-03-31 13:27:11 -04001220 /*
1221 * rename don't use btrfs_join_transaction, so, once we
1222 * set the transaction to blocked above, we aren't going
1223 * to get any new ordered operations. We can safely run
1224 * it here and no for sure that nothing new will be added
1225 * to the list
1226 */
1227 btrfs_run_ordered_operations(root, 1);
1228
Chris Masoned3b3d3142010-05-25 10:12:41 -04001229 prepare_to_wait(&cur_trans->writer_wait, &wait,
1230 TASK_UNINTERRUPTIBLE);
1231
Josef Bacik13c5a932011-04-11 15:45:29 -04001232 if (atomic_read(&cur_trans->num_writers) > 1)
Sage Weil99d16cb2010-10-29 15:37:34 -04001233 schedule_timeout(MAX_SCHEDULE_TIMEOUT);
1234 else if (should_grow)
1235 schedule_timeout(1);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001236
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001237 finish_wait(&cur_trans->writer_wait, &wait);
Josef Bacik13c5a932011-04-11 15:45:29 -04001238 } while (atomic_read(&cur_trans->num_writers) > 1 ||
Chris Mason89573b92009-03-12 20:12:45 -04001239 (should_grow && cur_trans->num_joined != joined));
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001240
Chris Mason75857172011-06-13 20:00:16 -04001241 /*
Josef Baciked0ca142011-06-14 16:22:15 -04001242 * Ok now we need to make sure to block out any other joins while we
1243 * commit the transaction. We could have started a join before setting
1244 * no_join so make sure to wait for num_writers to == 1 again.
1245 */
1246 spin_lock(&root->fs_info->trans_lock);
1247 root->fs_info->trans_no_join = 1;
1248 spin_unlock(&root->fs_info->trans_lock);
1249 wait_event(cur_trans->writer_wait,
1250 atomic_read(&cur_trans->num_writers) == 1);
1251
Chris Masone038dca2011-06-17 14:16:13 -04001252 /*
Chris Mason75857172011-06-13 20:00:16 -04001253 * the reloc mutex makes sure that we stop
1254 * the balancing code from coming in and moving
1255 * extents around in the middle of the commit
1256 */
1257 mutex_lock(&root->fs_info->reloc_mutex);
1258
Chris Masone9993762011-06-17 16:14:09 -04001259 ret = btrfs_run_delayed_items(trans, root);
Chris Mason3063d292008-01-08 15:46:30 -05001260 BUG_ON(ret);
1261
Chris Masone9993762011-06-17 16:14:09 -04001262 ret = create_pending_snapshots(trans, root->fs_info);
Miao Xie16cdcec2011-04-22 18:12:22 +08001263 BUG_ON(ret);
1264
Chris Mason56bec292009-03-13 10:10:06 -04001265 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1266 BUG_ON(ret);
1267
Chris Masone9993762011-06-17 16:14:09 -04001268 /*
1269 * make sure none of the code above managed to slip in a
1270 * delayed item
1271 */
1272 btrfs_assert_delayed_root_empty(root);
1273
Chris Mason2c90e5d2007-04-02 10:50:19 -04001274 WARN_ON(cur_trans != trans->transaction);
Chris Masondc17ff82008-01-08 15:46:30 -05001275
Arne Jansena2de7332011-03-08 14:14:00 +01001276 btrfs_scrub_pause(root);
Chris Masone02119d2008-09-05 16:13:11 -04001277 /* btrfs_commit_tree_roots is responsible for getting the
1278 * various roots consistent with each other. Every pointer
1279 * in the tree of tree roots has to point to the most up to date
1280 * root for every subvolume and other tree. So, we have to keep
1281 * the tree logging code from jumping in and changing any
1282 * of the trees.
1283 *
1284 * At this point in the commit, there can't be any tree-log
1285 * writers, but a little lower down we drop the trans mutex
1286 * and let new people in. By holding the tree_log_mutex
1287 * from now until after the super is written, we avoid races
1288 * with the tree-log code.
1289 */
1290 mutex_lock(&root->fs_info->tree_log_mutex);
Zheng Yan1a40e232008-09-26 10:09:34 -04001291
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001292 ret = commit_fs_roots(trans, root);
Chris Mason54aa1f42007-06-22 14:16:25 -04001293 BUG_ON(ret);
1294
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001295 /* commit_fs_roots gets rid of all the tree log roots, it is now
Chris Masone02119d2008-09-05 16:13:11 -04001296 * safe to free the root of tree log roots
1297 */
1298 btrfs_free_log_root_tree(trans, root->fs_info);
1299
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001300 ret = commit_cowonly_roots(trans, root);
Chris Mason79154b12007-03-22 15:59:16 -04001301 BUG_ON(ret);
Chris Mason54aa1f42007-06-22 14:16:25 -04001302
Yan Zheng11833d62009-09-11 16:11:19 -04001303 btrfs_prepare_extent_commit(trans, root);
1304
Chris Mason78fae272007-03-25 11:35:08 -04001305 cur_trans = root->fs_info->running_transaction;
Chris Mason5f39d392007-10-15 16:14:19 -04001306
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001307 btrfs_set_root_node(&root->fs_info->tree_root->root_item,
1308 root->fs_info->tree_root->node);
Josef Bacik817d52f2009-07-13 21:29:25 -04001309 switch_commit_root(root->fs_info->tree_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001310
1311 btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
1312 root->fs_info->chunk_root->node);
Josef Bacik817d52f2009-07-13 21:29:25 -04001313 switch_commit_root(root->fs_info->chunk_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001314
1315 update_super_roots(root);
Chris Masone02119d2008-09-05 16:13:11 -04001316
1317 if (!root->fs_info->log_root_recovering) {
David Sterba6c417612011-04-13 15:41:04 +02001318 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
1319 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
Chris Masone02119d2008-09-05 16:13:11 -04001320 }
1321
David Sterba6c417612011-04-13 15:41:04 +02001322 memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
1323 sizeof(*root->fs_info->super_copy));
Chris Masonccd467d2007-06-28 15:57:36 -04001324
Chris Masonf9295742008-07-17 12:54:14 -04001325 trans->transaction->blocked = 0;
Josef Bacika4abeea2011-04-11 17:25:13 -04001326 spin_lock(&root->fs_info->trans_lock);
1327 root->fs_info->running_transaction = NULL;
1328 root->fs_info->trans_no_join = 0;
1329 spin_unlock(&root->fs_info->trans_lock);
Chris Mason75857172011-06-13 20:00:16 -04001330 mutex_unlock(&root->fs_info->reloc_mutex);
Chris Masonb7ec40d2009-03-12 20:12:45 -04001331
Chris Masonf9295742008-07-17 12:54:14 -04001332 wake_up(&root->fs_info->transaction_wait);
Chris Masone6dcd2d2008-07-17 12:53:50 -04001333
Chris Mason79154b12007-03-22 15:59:16 -04001334 ret = btrfs_write_and_wait_transaction(trans, root);
1335 BUG_ON(ret);
Yan Zhenga512bbf2008-12-08 16:46:26 -05001336 write_ctree_super(trans, root, 0);
Chris Mason4313b392008-01-03 09:08:48 -05001337
Chris Masone02119d2008-09-05 16:13:11 -04001338 /*
1339 * the super is written, we can safely allow the tree-loggers
1340 * to go about their business
1341 */
1342 mutex_unlock(&root->fs_info->tree_log_mutex);
1343
Yan Zheng11833d62009-09-11 16:11:19 -04001344 btrfs_finish_extent_commit(trans, root);
Chris Mason4313b392008-01-03 09:08:48 -05001345
Chris Mason2c90e5d2007-04-02 10:50:19 -04001346 cur_trans->commit_done = 1;
Chris Masonb7ec40d2009-03-12 20:12:45 -04001347
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001348 root->fs_info->last_trans_committed = cur_trans->transid;
Josef Bacik817d52f2009-07-13 21:29:25 -04001349
Chris Mason2c90e5d2007-04-02 10:50:19 -04001350 wake_up(&cur_trans->commit_wait);
Chris Mason3de45862008-11-17 21:02:50 -05001351
Josef Bacika4abeea2011-04-11 17:25:13 -04001352 spin_lock(&root->fs_info->trans_lock);
Josef Bacik13c5a932011-04-11 15:45:29 -04001353 list_del_init(&cur_trans->list);
Josef Bacika4abeea2011-04-11 17:25:13 -04001354 spin_unlock(&root->fs_info->trans_lock);
1355
Chris Mason79154b12007-03-22 15:59:16 -04001356 put_transaction(cur_trans);
Chris Mason78fae272007-03-25 11:35:08 -04001357 put_transaction(cur_trans);
Josef Bacik58176a92007-08-29 15:47:34 -04001358
liubo1abe9b82011-03-24 11:18:59 +00001359 trace_btrfs_transaction_commit(root);
1360
Arne Jansena2de7332011-03-08 14:14:00 +01001361 btrfs_scrub_continue(root);
1362
Josef Bacik9ed74f22009-09-11 16:12:44 -04001363 if (current->journal_info == trans)
1364 current->journal_info = NULL;
1365
Chris Mason2c90e5d2007-04-02 10:50:19 -04001366 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Yan, Zheng24bbcf042009-11-12 09:36:34 +00001367
1368 if (current != root->fs_info->transaction_kthread)
1369 btrfs_run_delayed_iputs(root);
1370
Chris Mason79154b12007-03-22 15:59:16 -04001371 return ret;
1372}
1373
Chris Masond352ac62008-09-29 15:18:18 -04001374/*
1375 * interface function to delete all the snapshots we have scheduled for deletion
1376 */
Chris Masone9d0b132007-08-10 14:06:19 -04001377int btrfs_clean_old_snapshots(struct btrfs_root *root)
1378{
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001379 LIST_HEAD(list);
1380 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Masone9d0b132007-08-10 14:06:19 -04001381
Josef Bacika4abeea2011-04-11 17:25:13 -04001382 spin_lock(&fs_info->trans_lock);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001383 list_splice_init(&fs_info->dead_roots, &list);
Josef Bacika4abeea2011-04-11 17:25:13 -04001384 spin_unlock(&fs_info->trans_lock);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001385
1386 while (!list_empty(&list)) {
1387 root = list_entry(list.next, struct btrfs_root, root_list);
Yan, Zheng76dda932009-09-21 16:00:26 -04001388 list_del(&root->root_list);
1389
Miao Xie16cdcec2011-04-22 18:12:22 +08001390 btrfs_kill_all_delayed_nodes(root);
1391
Yan, Zheng76dda932009-09-21 16:00:26 -04001392 if (btrfs_header_backref_rev(root->node) <
1393 BTRFS_MIXED_BACKREF_REV)
Arne Jansen66d7e7f2011-09-12 15:26:38 +02001394 btrfs_drop_snapshot(root, NULL, 0, 0);
Yan, Zheng76dda932009-09-21 16:00:26 -04001395 else
Arne Jansen66d7e7f2011-09-12 15:26:38 +02001396 btrfs_drop_snapshot(root, NULL, 1, 0);
Chris Masone9d0b132007-08-10 14:06:19 -04001397 }
1398 return 0;
1399}