blob: 66e4c66cc63bf114900c6da4462c32e6bd0e65e0 [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 Masond3c2fdc2007-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"
Chris Mason79154b12007-03-22 15:59:16 -040030
Chris Mason0f7d52f2007-04-09 10:42:37 -040031#define BTRFS_ROOT_TRANS_TAG 0
32
Chris Mason80b67942008-02-01 16:35:04 -050033static noinline void put_transaction(struct btrfs_transaction *transaction)
Chris Mason79154b12007-03-22 15:59:16 -040034{
Chris Mason2c90e5d2007-04-02 10:50:19 -040035 WARN_ON(transaction->use_count == 0);
Chris Mason79154b12007-03-22 15:59:16 -040036 transaction->use_count--;
Chris Mason78fae272007-03-25 11:35:08 -040037 if (transaction->use_count == 0) {
Chris Mason8fd17792007-04-19 21:01:03 -040038 list_del_init(&transaction->list);
Chris Mason2c90e5d2007-04-02 10:50:19 -040039 memset(transaction, 0, sizeof(*transaction));
40 kmem_cache_free(btrfs_transaction_cachep, transaction);
Chris Mason78fae272007-03-25 11:35:08 -040041 }
Chris Mason79154b12007-03-22 15:59:16 -040042}
43
Josef Bacik817d52f2009-07-13 21:29:25 -040044static noinline void switch_commit_root(struct btrfs_root *root)
45{
Josef Bacik817d52f2009-07-13 21:29:25 -040046 free_extent_buffer(root->commit_root);
47 root->commit_root = btrfs_root_node(root);
Josef Bacik817d52f2009-07-13 21:29:25 -040048}
49
Chris Masond352ac62008-09-29 15:18:18 -040050/*
51 * either allocate a new transaction or hop into the existing one
52 */
Chris Mason80b67942008-02-01 16:35:04 -050053static noinline int join_transaction(struct btrfs_root *root)
Chris Mason79154b12007-03-22 15:59:16 -040054{
55 struct btrfs_transaction *cur_trans;
56 cur_trans = root->fs_info->running_transaction;
57 if (!cur_trans) {
Chris Mason2c90e5d2007-04-02 10:50:19 -040058 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep,
59 GFP_NOFS);
Chris Mason79154b12007-03-22 15:59:16 -040060 BUG_ON(!cur_trans);
Chris Mason0f7d52f2007-04-09 10:42:37 -040061 root->fs_info->generation++;
Josef Bacik15ee9bc2007-08-10 16:22:09 -040062 cur_trans->num_writers = 1;
63 cur_trans->num_joined = 0;
Chris Mason0f7d52f2007-04-09 10:42:37 -040064 cur_trans->transid = root->fs_info->generation;
Chris Mason79154b12007-03-22 15:59:16 -040065 init_waitqueue_head(&cur_trans->writer_wait);
66 init_waitqueue_head(&cur_trans->commit_wait);
67 cur_trans->in_commit = 0;
Chris Masonf9295742008-07-17 12:54:14 -040068 cur_trans->blocked = 0;
Chris Masond5719762007-03-23 10:01:08 -040069 cur_trans->use_count = 1;
Chris Mason79154b12007-03-22 15:59:16 -040070 cur_trans->commit_done = 0;
Chris Mason08607c12007-06-08 15:33:54 -040071 cur_trans->start_time = get_seconds();
Chris Mason56bec292009-03-13 10:10:06 -040072
Eric Paris6bef4d32010-02-23 19:43:04 +000073 cur_trans->delayed_refs.root = RB_ROOT;
Chris Mason56bec292009-03-13 10:10:06 -040074 cur_trans->delayed_refs.num_entries = 0;
Chris Masonc3e69d52009-03-13 10:17:05 -040075 cur_trans->delayed_refs.num_heads_ready = 0;
76 cur_trans->delayed_refs.num_heads = 0;
Chris Mason56bec292009-03-13 10:10:06 -040077 cur_trans->delayed_refs.flushing = 0;
Chris Masonc3e69d52009-03-13 10:17:05 -040078 cur_trans->delayed_refs.run_delayed_start = 0;
Chris Mason56bec292009-03-13 10:10:06 -040079 spin_lock_init(&cur_trans->delayed_refs.lock);
80
Chris Mason3063d292008-01-08 15:46:30 -050081 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
Chris Mason8fd17792007-04-19 21:01:03 -040082 list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
Chris Masond1310b22008-01-24 16:13:08 -050083 extent_io_tree_init(&cur_trans->dirty_pages,
Chris Mason5f39d392007-10-15 16:14:19 -040084 root->fs_info->btree_inode->i_mapping,
85 GFP_NOFS);
Chris Mason48ec2cf2008-06-09 09:35:50 -040086 spin_lock(&root->fs_info->new_trans_lock);
87 root->fs_info->running_transaction = cur_trans;
88 spin_unlock(&root->fs_info->new_trans_lock);
Josef Bacik15ee9bc2007-08-10 16:22:09 -040089 } else {
90 cur_trans->num_writers++;
91 cur_trans->num_joined++;
Chris Mason79154b12007-03-22 15:59:16 -040092 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -040093
Chris Mason79154b12007-03-22 15:59:16 -040094 return 0;
95}
96
Chris Masond352ac62008-09-29 15:18:18 -040097/*
Chris Masond3977122009-01-05 21:25:51 -050098 * this does all the record keeping required to make sure that a reference
99 * counted root is properly recorded in a given transaction. This is required
100 * to make sure the old root from before we joined the transaction is deleted
101 * when the transaction commits
Chris Masond352ac62008-09-29 15:18:18 -0400102 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400103static noinline int record_root_in_trans(struct btrfs_trans_handle *trans,
104 struct btrfs_root *root)
Chris Mason6702ed42007-08-07 16:15:09 -0400105{
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400106 if (root->ref_cows && root->last_trans < trans->transid) {
Chris Mason6702ed42007-08-07 16:15:09 -0400107 WARN_ON(root == root->fs_info->extent_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400108 WARN_ON(root->commit_root != root->node);
Yan Zheng31153d82008-07-28 15:32:19 -0400109
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400110 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
111 (unsigned long)root->root_key.objectid,
112 BTRFS_ROOT_TRANS_TAG);
113 root->last_trans = trans->transid;
114 btrfs_init_reloc_root(trans, root);
Chris Mason6702ed42007-08-07 16:15:09 -0400115 }
116 return 0;
117}
118
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400119int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
120 struct btrfs_root *root)
121{
122 if (!root->ref_cows)
123 return 0;
124
125 mutex_lock(&root->fs_info->trans_mutex);
126 if (root->last_trans == trans->transid) {
127 mutex_unlock(&root->fs_info->trans_mutex);
128 return 0;
129 }
130
131 record_root_in_trans(trans, root);
132 mutex_unlock(&root->fs_info->trans_mutex);
133 return 0;
134}
135
Chris Masond352ac62008-09-29 15:18:18 -0400136/* wait for commit against the current transaction to become unblocked
137 * when this is done, it is safe to start a new transaction, but the current
138 * transaction might not be fully on disk.
139 */
Chris Mason37d1aee2008-07-31 10:48:37 -0400140static void wait_current_trans(struct btrfs_root *root)
Chris Mason79154b12007-03-22 15:59:16 -0400141{
Chris Masonf9295742008-07-17 12:54:14 -0400142 struct btrfs_transaction *cur_trans;
Chris Mason79154b12007-03-22 15:59:16 -0400143
Chris Masonf9295742008-07-17 12:54:14 -0400144 cur_trans = root->fs_info->running_transaction;
Chris Mason37d1aee2008-07-31 10:48:37 -0400145 if (cur_trans && cur_trans->blocked) {
Chris Masonf9295742008-07-17 12:54:14 -0400146 DEFINE_WAIT(wait);
147 cur_trans->use_count++;
Chris Masond3977122009-01-05 21:25:51 -0500148 while (1) {
Chris Masonf9295742008-07-17 12:54:14 -0400149 prepare_to_wait(&root->fs_info->transaction_wait, &wait,
150 TASK_UNINTERRUPTIBLE);
Zhao Lei471fa172010-03-25 12:35:14 +0000151 if (!cur_trans->blocked)
Chris Masonf9295742008-07-17 12:54:14 -0400152 break;
Zhao Lei471fa172010-03-25 12:35:14 +0000153 mutex_unlock(&root->fs_info->trans_mutex);
154 schedule();
155 mutex_lock(&root->fs_info->trans_mutex);
Chris Masonf9295742008-07-17 12:54:14 -0400156 }
Zhao Lei471fa172010-03-25 12:35:14 +0000157 finish_wait(&root->fs_info->transaction_wait, &wait);
Chris Masonf9295742008-07-17 12:54:14 -0400158 put_transaction(cur_trans);
159 }
Chris Mason37d1aee2008-07-31 10:48:37 -0400160}
161
Josef Bacik249ac1e2009-11-10 21:23:48 -0500162enum btrfs_trans_type {
163 TRANS_START,
164 TRANS_JOIN,
165 TRANS_USERSPACE,
166};
167
Yan, Zhenga22285a2010-05-16 10:48:46 -0400168static int may_wait_transaction(struct btrfs_root *root, int type)
Chris Mason37d1aee2008-07-31 10:48:37 -0400169{
Chris Mason4bef0842008-09-08 11:18:08 -0400170 if (!root->fs_info->log_root_recovering &&
Josef Bacik249ac1e2009-11-10 21:23:48 -0500171 ((type == TRANS_START && !root->fs_info->open_ioctl_trans) ||
172 type == TRANS_USERSPACE))
Yan, Zhenga22285a2010-05-16 10:48:46 -0400173 return 1;
174 return 0;
175}
176
177static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
178 u64 num_items, int type)
179{
180 struct btrfs_trans_handle *h;
181 struct btrfs_transaction *cur_trans;
182 int retries = 0;
183 int ret;
184again:
185 h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
186 if (!h)
187 return ERR_PTR(-ENOMEM);
188
189 mutex_lock(&root->fs_info->trans_mutex);
190 if (may_wait_transaction(root, type))
Chris Mason37d1aee2008-07-31 10:48:37 -0400191 wait_current_trans(root);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400192
Chris Mason79154b12007-03-22 15:59:16 -0400193 ret = join_transaction(root);
194 BUG_ON(ret);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400195
Yan, Zhenga22285a2010-05-16 10:48:46 -0400196 cur_trans = root->fs_info->running_transaction;
197 cur_trans->use_count++;
198 mutex_unlock(&root->fs_info->trans_mutex);
199
200 h->transid = cur_trans->transid;
201 h->transaction = cur_trans;
Chris Mason79154b12007-03-22 15:59:16 -0400202 h->blocks_used = 0;
Yan Zhengd2fb3432008-12-11 16:30:39 -0500203 h->block_group = 0;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400204 h->bytes_reserved = 0;
Chris Mason56bec292009-03-13 10:10:06 -0400205 h->delayed_ref_updates = 0;
Yan, Zhengf0486c62010-05-16 10:46:25 -0400206 h->block_rsv = NULL;
Chris Masonb7ec40d2009-03-12 20:12:45 -0400207
Yan, Zhenga22285a2010-05-16 10:48:46 -0400208 smp_mb();
209 if (cur_trans->blocked && may_wait_transaction(root, type)) {
210 btrfs_commit_transaction(h, root);
211 goto again;
212 }
Josef Bacik9ed74f22009-09-11 16:12:44 -0400213
Yan, Zhenga22285a2010-05-16 10:48:46 -0400214 if (num_items > 0) {
215 ret = btrfs_trans_reserve_metadata(h, root, num_items,
216 &retries);
217 if (ret == -EAGAIN) {
218 btrfs_commit_transaction(h, root);
219 goto again;
220 }
221 if (ret < 0) {
222 btrfs_end_transaction(h, root);
223 return ERR_PTR(ret);
224 }
225 }
226
227 mutex_lock(&root->fs_info->trans_mutex);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400228 record_root_in_trans(h, root);
Chris Mason79154b12007-03-22 15:59:16 -0400229 mutex_unlock(&root->fs_info->trans_mutex);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400230
231 if (!current->journal_info && type != TRANS_USERSPACE)
232 current->journal_info = h;
Chris Mason79154b12007-03-22 15:59:16 -0400233 return h;
234}
235
Chris Masonf9295742008-07-17 12:54:14 -0400236struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
Yan, Zhenga22285a2010-05-16 10:48:46 -0400237 int num_items)
Chris Masonf9295742008-07-17 12:54:14 -0400238{
Yan, Zhenga22285a2010-05-16 10:48:46 -0400239 return start_transaction(root, num_items, TRANS_START);
Chris Masonf9295742008-07-17 12:54:14 -0400240}
241struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root,
242 int num_blocks)
243{
Yan, Zhenga22285a2010-05-16 10:48:46 -0400244 return start_transaction(root, 0, TRANS_JOIN);
Chris Masonf9295742008-07-17 12:54:14 -0400245}
246
Sage Weil9ca9ee02008-08-04 10:41:27 -0400247struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r,
248 int num_blocks)
249{
Yan, Zhenga22285a2010-05-16 10:48:46 -0400250 return start_transaction(r, 0, TRANS_USERSPACE);
Sage Weil9ca9ee02008-08-04 10:41:27 -0400251}
252
Chris Masond352ac62008-09-29 15:18:18 -0400253/* wait for a transaction commit to be fully complete */
Chris Mason89ce8a62008-06-25 16:01:31 -0400254static noinline int wait_for_commit(struct btrfs_root *root,
255 struct btrfs_transaction *commit)
256{
257 DEFINE_WAIT(wait);
258 mutex_lock(&root->fs_info->trans_mutex);
Chris Masond3977122009-01-05 21:25:51 -0500259 while (!commit->commit_done) {
Chris Mason89ce8a62008-06-25 16:01:31 -0400260 prepare_to_wait(&commit->commit_wait, &wait,
261 TASK_UNINTERRUPTIBLE);
262 if (commit->commit_done)
263 break;
264 mutex_unlock(&root->fs_info->trans_mutex);
265 schedule();
266 mutex_lock(&root->fs_info->trans_mutex);
267 }
268 mutex_unlock(&root->fs_info->trans_mutex);
269 finish_wait(&commit->commit_wait, &wait);
270 return 0;
271}
272
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400273#if 0
Chris Masond352ac62008-09-29 15:18:18 -0400274/*
Chris Masond3977122009-01-05 21:25:51 -0500275 * rate limit against the drop_snapshot code. This helps to slow down new
276 * operations if the drop_snapshot code isn't able to keep up.
Chris Masond352ac62008-09-29 15:18:18 -0400277 */
Chris Mason37d1aee2008-07-31 10:48:37 -0400278static void throttle_on_drops(struct btrfs_root *root)
Chris Masonab78c842008-07-29 16:15:18 -0400279{
280 struct btrfs_fs_info *info = root->fs_info;
Chris Mason2dd3e672008-08-04 08:20:15 -0400281 int harder_count = 0;
Chris Masonab78c842008-07-29 16:15:18 -0400282
Chris Mason2dd3e672008-08-04 08:20:15 -0400283harder:
Chris Masonab78c842008-07-29 16:15:18 -0400284 if (atomic_read(&info->throttles)) {
285 DEFINE_WAIT(wait);
286 int thr;
Chris Masonab78c842008-07-29 16:15:18 -0400287 thr = atomic_read(&info->throttle_gen);
288
289 do {
290 prepare_to_wait(&info->transaction_throttle,
291 &wait, TASK_UNINTERRUPTIBLE);
292 if (!atomic_read(&info->throttles)) {
293 finish_wait(&info->transaction_throttle, &wait);
294 break;
295 }
296 schedule();
297 finish_wait(&info->transaction_throttle, &wait);
298 } while (thr == atomic_read(&info->throttle_gen));
Chris Mason2dd3e672008-08-04 08:20:15 -0400299 harder_count++;
300
301 if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 &&
302 harder_count < 2)
303 goto harder;
304
305 if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 &&
306 harder_count < 10)
307 goto harder;
308
309 if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 &&
310 harder_count < 20)
311 goto harder;
Chris Masonab78c842008-07-29 16:15:18 -0400312 }
313}
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400314#endif
Chris Masonab78c842008-07-29 16:15:18 -0400315
Chris Mason37d1aee2008-07-31 10:48:37 -0400316void btrfs_throttle(struct btrfs_root *root)
317{
318 mutex_lock(&root->fs_info->trans_mutex);
Sage Weil9ca9ee02008-08-04 10:41:27 -0400319 if (!root->fs_info->open_ioctl_trans)
320 wait_current_trans(root);
Chris Mason37d1aee2008-07-31 10:48:37 -0400321 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason37d1aee2008-07-31 10:48:37 -0400322}
323
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400324static int should_end_transaction(struct btrfs_trans_handle *trans,
325 struct btrfs_root *root)
326{
327 int ret;
328 ret = btrfs_block_rsv_check(trans, root,
329 &root->fs_info->global_block_rsv, 0, 5);
330 return ret ? 1 : 0;
331}
332
333int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
334 struct btrfs_root *root)
335{
336 struct btrfs_transaction *cur_trans = trans->transaction;
337 int updates;
338
339 if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
340 return 1;
341
342 updates = trans->delayed_ref_updates;
343 trans->delayed_ref_updates = 0;
344 if (updates)
345 btrfs_run_delayed_refs(trans, root, updates);
346
347 return should_end_transaction(trans, root);
348}
349
Chris Mason89ce8a62008-06-25 16:01:31 -0400350static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
351 struct btrfs_root *root, int throttle)
Chris Mason79154b12007-03-22 15:59:16 -0400352{
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400353 struct btrfs_transaction *cur_trans = trans->transaction;
Chris Masonab78c842008-07-29 16:15:18 -0400354 struct btrfs_fs_info *info = root->fs_info;
Chris Masonc3e69d52009-03-13 10:17:05 -0400355 int count = 0;
Chris Masond6e4a422007-04-06 15:37:36 -0400356
Chris Masonc3e69d52009-03-13 10:17:05 -0400357 while (count < 4) {
358 unsigned long cur = trans->delayed_ref_updates;
359 trans->delayed_ref_updates = 0;
360 if (cur &&
361 trans->transaction->delayed_refs.num_heads_ready > 64) {
362 trans->delayed_ref_updates = 0;
Chris Masonb7ec40d2009-03-12 20:12:45 -0400363
364 /*
365 * do a full flush if the transaction is trying
366 * to close
367 */
368 if (trans->transaction->delayed_refs.flushing)
369 cur = 0;
Chris Masonc3e69d52009-03-13 10:17:05 -0400370 btrfs_run_delayed_refs(trans, root, cur);
371 } else {
372 break;
373 }
374 count++;
Chris Mason56bec292009-03-13 10:10:06 -0400375 }
376
Yan, Zhenga22285a2010-05-16 10:48:46 -0400377 btrfs_trans_release_metadata(trans, root);
378
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400379 if (!root->fs_info->open_ioctl_trans &&
380 should_end_transaction(trans, root))
381 trans->transaction->blocked = 1;
382
383 if (cur_trans->blocked && !cur_trans->in_commit) {
384 if (throttle)
385 return btrfs_commit_transaction(trans, root);
386 else
387 wake_up_process(info->transaction_kthread);
388 }
389
Chris Masonab78c842008-07-29 16:15:18 -0400390 mutex_lock(&info->trans_mutex);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400391 WARN_ON(cur_trans != info->running_transaction);
Chris Masond5719762007-03-23 10:01:08 -0400392 WARN_ON(cur_trans->num_writers < 1);
Chris Masonccd467d2007-06-28 15:57:36 -0400393 cur_trans->num_writers--;
Chris Mason89ce8a62008-06-25 16:01:31 -0400394
Chris Mason79154b12007-03-22 15:59:16 -0400395 if (waitqueue_active(&cur_trans->writer_wait))
396 wake_up(&cur_trans->writer_wait);
Chris Mason79154b12007-03-22 15:59:16 -0400397 put_transaction(cur_trans);
Chris Masonab78c842008-07-29 16:15:18 -0400398 mutex_unlock(&info->trans_mutex);
Josef Bacik9ed74f22009-09-11 16:12:44 -0400399
400 if (current->journal_info == trans)
401 current->journal_info = NULL;
Chris Masond6025572007-03-30 14:27:56 -0400402 memset(trans, 0, sizeof(*trans));
Chris Mason2c90e5d2007-04-02 10:50:19 -0400403 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Chris Masonab78c842008-07-29 16:15:18 -0400404
Yan, Zheng24bbcf02009-11-12 09:36:34 +0000405 if (throttle)
406 btrfs_run_delayed_iputs(root);
407
Chris Mason79154b12007-03-22 15:59:16 -0400408 return 0;
409}
410
Chris Mason89ce8a62008-06-25 16:01:31 -0400411int btrfs_end_transaction(struct btrfs_trans_handle *trans,
412 struct btrfs_root *root)
413{
414 return __btrfs_end_transaction(trans, root, 0);
415}
416
417int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
418 struct btrfs_root *root)
419{
420 return __btrfs_end_transaction(trans, root, 1);
421}
422
Chris Masond352ac62008-09-29 15:18:18 -0400423/*
424 * when btree blocks are allocated, they have some corresponding bits set for
425 * them in one of two extent_io trees. This is used to make sure all of
Chris Mason690587d2009-10-13 13:29:19 -0400426 * those extents are sent to disk but does not wait on them
Chris Masond352ac62008-09-29 15:18:18 -0400427 */
Chris Mason690587d2009-10-13 13:29:19 -0400428int btrfs_write_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000429 struct extent_io_tree *dirty_pages, int mark)
Chris Mason79154b12007-03-22 15:59:16 -0400430{
Chris Mason7c4452b2007-04-28 09:29:35 -0400431 int ret;
Chris Mason777e6bd2008-08-15 15:34:15 -0400432 int err = 0;
Chris Mason7c4452b2007-04-28 09:29:35 -0400433 int werr = 0;
434 struct page *page;
Chris Mason7c4452b2007-04-28 09:29:35 -0400435 struct inode *btree_inode = root->fs_info->btree_inode;
Chris Mason777e6bd2008-08-15 15:34:15 -0400436 u64 start = 0;
Chris Mason5f39d392007-10-15 16:14:19 -0400437 u64 end;
438 unsigned long index;
Chris Mason7c4452b2007-04-28 09:29:35 -0400439
Chris Masond3977122009-01-05 21:25:51 -0500440 while (1) {
Chris Mason777e6bd2008-08-15 15:34:15 -0400441 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000442 mark);
Chris Mason5f39d392007-10-15 16:14:19 -0400443 if (ret)
Chris Mason7c4452b2007-04-28 09:29:35 -0400444 break;
Chris Masond3977122009-01-05 21:25:51 -0500445 while (start <= end) {
Chris Mason777e6bd2008-08-15 15:34:15 -0400446 cond_resched();
447
Chris Mason5f39d392007-10-15 16:14:19 -0400448 index = start >> PAGE_CACHE_SHIFT;
Chris Mason35ebb932007-10-30 16:56:53 -0400449 start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
Chris Mason4bef0842008-09-08 11:18:08 -0400450 page = find_get_page(btree_inode->i_mapping, index);
Chris Mason7c4452b2007-04-28 09:29:35 -0400451 if (!page)
452 continue;
Chris Mason4bef0842008-09-08 11:18:08 -0400453
454 btree_lock_page_hook(page);
455 if (!page->mapping) {
456 unlock_page(page);
457 page_cache_release(page);
458 continue;
459 }
460
Chris Mason6702ed42007-08-07 16:15:09 -0400461 if (PageWriteback(page)) {
462 if (PageDirty(page))
463 wait_on_page_writeback(page);
464 else {
465 unlock_page(page);
466 page_cache_release(page);
467 continue;
468 }
469 }
Chris Mason7c4452b2007-04-28 09:29:35 -0400470 err = write_one_page(page, 0);
471 if (err)
472 werr = err;
473 page_cache_release(page);
474 }
475 }
Chris Mason690587d2009-10-13 13:29:19 -0400476 if (err)
477 werr = err;
478 return werr;
479}
480
481/*
482 * when btree blocks are allocated, they have some corresponding bits set for
483 * them in one of two extent_io trees. This is used to make sure all of
484 * those extents are on disk for transaction or log commit. We wait
485 * on all the pages and clear them from the dirty pages state tree
486 */
487int btrfs_wait_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000488 struct extent_io_tree *dirty_pages, int mark)
Chris Mason690587d2009-10-13 13:29:19 -0400489{
490 int ret;
491 int err = 0;
492 int werr = 0;
493 struct page *page;
494 struct inode *btree_inode = root->fs_info->btree_inode;
495 u64 start = 0;
496 u64 end;
497 unsigned long index;
498
Chris Masond3977122009-01-05 21:25:51 -0500499 while (1) {
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000500 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
501 mark);
Chris Mason777e6bd2008-08-15 15:34:15 -0400502 if (ret)
503 break;
504
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000505 clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
Chris Masond3977122009-01-05 21:25:51 -0500506 while (start <= end) {
Chris Mason777e6bd2008-08-15 15:34:15 -0400507 index = start >> PAGE_CACHE_SHIFT;
508 start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
509 page = find_get_page(btree_inode->i_mapping, index);
510 if (!page)
511 continue;
512 if (PageDirty(page)) {
Chris Mason4bef0842008-09-08 11:18:08 -0400513 btree_lock_page_hook(page);
514 wait_on_page_writeback(page);
Chris Mason777e6bd2008-08-15 15:34:15 -0400515 err = write_one_page(page, 0);
516 if (err)
517 werr = err;
518 }
Chris Mason105d9312008-11-18 12:13:12 -0500519 wait_on_page_writeback(page);
Chris Mason777e6bd2008-08-15 15:34:15 -0400520 page_cache_release(page);
521 cond_resched();
522 }
523 }
Chris Mason7c4452b2007-04-28 09:29:35 -0400524 if (err)
525 werr = err;
526 return werr;
Chris Mason79154b12007-03-22 15:59:16 -0400527}
528
Chris Mason690587d2009-10-13 13:29:19 -0400529/*
530 * when btree blocks are allocated, they have some corresponding bits set for
531 * them in one of two extent_io trees. This is used to make sure all of
532 * those extents are on disk for transaction or log commit
533 */
534int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000535 struct extent_io_tree *dirty_pages, int mark)
Chris Mason690587d2009-10-13 13:29:19 -0400536{
537 int ret;
538 int ret2;
539
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000540 ret = btrfs_write_marked_extents(root, dirty_pages, mark);
541 ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
Chris Mason690587d2009-10-13 13:29:19 -0400542 return ret || ret2;
543}
544
Chris Masond0c803c2008-09-11 16:17:57 -0400545int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
546 struct btrfs_root *root)
547{
548 if (!trans || !trans->transaction) {
549 struct inode *btree_inode;
550 btree_inode = root->fs_info->btree_inode;
551 return filemap_write_and_wait(btree_inode->i_mapping);
552 }
553 return btrfs_write_and_wait_marked_extents(root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000554 &trans->transaction->dirty_pages,
555 EXTENT_DIRTY);
Chris Masond0c803c2008-09-11 16:17:57 -0400556}
557
Chris Masond352ac62008-09-29 15:18:18 -0400558/*
559 * this is used to update the root pointer in the tree of tree roots.
560 *
561 * But, in the case of the extent allocation tree, updating the root
562 * pointer may allocate blocks which may change the root of the extent
563 * allocation tree.
564 *
565 * So, this loops and repeats and makes sure the cowonly root didn't
566 * change while the root pointer was being updated in the metadata.
567 */
Chris Mason0b86a832008-03-24 15:01:56 -0400568static int update_cowonly_root(struct btrfs_trans_handle *trans,
569 struct btrfs_root *root)
570{
571 int ret;
572 u64 old_root_bytenr;
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000573 u64 old_root_used;
Chris Mason0b86a832008-03-24 15:01:56 -0400574 struct btrfs_root *tree_root = root->fs_info->tree_root;
575
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000576 old_root_used = btrfs_root_used(&root->root_item);
Chris Mason0b86a832008-03-24 15:01:56 -0400577 btrfs_write_dirty_block_groups(trans, root);
Chris Mason56bec292009-03-13 10:10:06 -0400578
Chris Masond3977122009-01-05 21:25:51 -0500579 while (1) {
Chris Mason0b86a832008-03-24 15:01:56 -0400580 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000581 if (old_root_bytenr == root->node->start &&
582 old_root_used == btrfs_root_used(&root->root_item))
Chris Mason0b86a832008-03-24 15:01:56 -0400583 break;
Chris Mason87ef2bb2008-10-30 11:23:27 -0400584
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400585 btrfs_set_root_node(&root->root_item, root->node);
Chris Mason0b86a832008-03-24 15:01:56 -0400586 ret = btrfs_update_root(trans, tree_root,
587 &root->root_key,
588 &root->root_item);
589 BUG_ON(ret);
Chris Mason56bec292009-03-13 10:10:06 -0400590
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000591 old_root_used = btrfs_root_used(&root->root_item);
Yan Zheng4a8c9a62009-07-22 10:07:05 -0400592 ret = btrfs_write_dirty_block_groups(trans, root);
Chris Mason56bec292009-03-13 10:10:06 -0400593 BUG_ON(ret);
Chris Mason0b86a832008-03-24 15:01:56 -0400594 }
Yan Zheng276e6802009-07-30 09:40:40 -0400595
596 if (root != root->fs_info->extent_root)
597 switch_commit_root(root);
598
Chris Mason0b86a832008-03-24 15:01:56 -0400599 return 0;
600}
601
Chris Masond352ac62008-09-29 15:18:18 -0400602/*
603 * update all the cowonly tree roots on disk
604 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400605static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
606 struct btrfs_root *root)
Chris Mason79154b12007-03-22 15:59:16 -0400607{
Chris Mason79154b12007-03-22 15:59:16 -0400608 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Mason0b86a832008-03-24 15:01:56 -0400609 struct list_head *next;
Yan Zheng84234f32008-10-29 14:49:05 -0400610 struct extent_buffer *eb;
Chris Mason56bec292009-03-13 10:10:06 -0400611 int ret;
Yan Zheng84234f32008-10-29 14:49:05 -0400612
Chris Mason56bec292009-03-13 10:10:06 -0400613 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
614 BUG_ON(ret);
Chris Mason87ef2bb2008-10-30 11:23:27 -0400615
Yan Zheng84234f32008-10-29 14:49:05 -0400616 eb = btrfs_lock_root_node(fs_info->tree_root);
Chris Mason9fa8cfe2009-03-13 10:24:59 -0400617 btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
Yan Zheng84234f32008-10-29 14:49:05 -0400618 btrfs_tree_unlock(eb);
619 free_extent_buffer(eb);
Chris Mason79154b12007-03-22 15:59:16 -0400620
Chris Mason56bec292009-03-13 10:10:06 -0400621 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
622 BUG_ON(ret);
Chris Mason87ef2bb2008-10-30 11:23:27 -0400623
Chris Masond3977122009-01-05 21:25:51 -0500624 while (!list_empty(&fs_info->dirty_cowonly_roots)) {
Chris Mason0b86a832008-03-24 15:01:56 -0400625 next = fs_info->dirty_cowonly_roots.next;
626 list_del_init(next);
627 root = list_entry(next, struct btrfs_root, dirty_list);
Chris Mason87ef2bb2008-10-30 11:23:27 -0400628
Chris Mason0b86a832008-03-24 15:01:56 -0400629 update_cowonly_root(trans, root);
Chris Mason79154b12007-03-22 15:59:16 -0400630 }
Yan Zheng276e6802009-07-30 09:40:40 -0400631
632 down_write(&fs_info->extent_commit_sem);
633 switch_commit_root(fs_info->extent_root);
634 up_write(&fs_info->extent_commit_sem);
635
Chris Mason79154b12007-03-22 15:59:16 -0400636 return 0;
637}
638
Chris Masond352ac62008-09-29 15:18:18 -0400639/*
640 * dead roots are old snapshots that need to be deleted. This allocates
641 * a dirty root struct and adds it into the list of dead roots that need to
642 * be deleted
643 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400644int btrfs_add_dead_root(struct btrfs_root *root)
Chris Mason5eda7b52007-06-22 14:16:25 -0400645{
Yan Zhengb48652c2008-08-04 23:23:47 -0400646 mutex_lock(&root->fs_info->trans_mutex);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400647 list_add(&root->root_list, &root->fs_info->dead_roots);
Yan Zhengb48652c2008-08-04 23:23:47 -0400648 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason5eda7b52007-06-22 14:16:25 -0400649 return 0;
650}
651
Chris Masond352ac62008-09-29 15:18:18 -0400652/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400653 * update all the cowonly tree roots on disk
Chris Masond352ac62008-09-29 15:18:18 -0400654 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400655static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
656 struct btrfs_root *root)
Chris Mason0f7d52f2007-04-09 10:42:37 -0400657{
Chris Mason0f7d52f2007-04-09 10:42:37 -0400658 struct btrfs_root *gang[8];
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400659 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400660 int i;
661 int ret;
Chris Mason54aa1f42007-06-22 14:16:25 -0400662 int err = 0;
663
Chris Masond3977122009-01-05 21:25:51 -0500664 while (1) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400665 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
666 (void **)gang, 0,
Chris Mason0f7d52f2007-04-09 10:42:37 -0400667 ARRAY_SIZE(gang),
668 BTRFS_ROOT_TRANS_TAG);
669 if (ret == 0)
670 break;
671 for (i = 0; i < ret; i++) {
672 root = gang[i];
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400673 radix_tree_tag_clear(&fs_info->fs_roots_radix,
674 (unsigned long)root->root_key.objectid,
675 BTRFS_ROOT_TRANS_TAG);
Yan Zheng31153d82008-07-28 15:32:19 -0400676
Chris Masone02119d2008-09-05 16:13:11 -0400677 btrfs_free_log(trans, root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400678 btrfs_update_reloc_root(trans, root);
Yan, Zhengd68fc572010-05-16 10:49:58 -0400679 btrfs_orphan_commit_root(trans, root);
Chris Masone02119d2008-09-05 16:13:11 -0400680
Yan Zheng978d9102009-06-15 20:01:02 -0400681 if (root->commit_root != root->node) {
Josef Bacik817d52f2009-07-13 21:29:25 -0400682 switch_commit_root(root);
Yan Zheng978d9102009-06-15 20:01:02 -0400683 btrfs_set_root_node(&root->root_item,
684 root->node);
685 }
Chris Mason9f3a7422007-08-07 15:52:19 -0400686
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400687 err = btrfs_update_root(trans, fs_info->tree_root,
Chris Mason0f7d52f2007-04-09 10:42:37 -0400688 &root->root_key,
689 &root->root_item);
Chris Mason54aa1f42007-06-22 14:16:25 -0400690 if (err)
691 break;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400692 }
693 }
Chris Mason54aa1f42007-06-22 14:16:25 -0400694 return err;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400695}
696
Chris Masond352ac62008-09-29 15:18:18 -0400697/*
698 * defrag a given btree. If cacheonly == 1, this won't read from the disk,
699 * otherwise every leaf in the btree is read and defragged.
700 */
Chris Masone9d0b132007-08-10 14:06:19 -0400701int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
702{
703 struct btrfs_fs_info *info = root->fs_info;
Chris Masone9d0b132007-08-10 14:06:19 -0400704 struct btrfs_trans_handle *trans;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400705 int ret;
Chris Masond3c2fdc2007-09-17 10:58:06 -0400706 unsigned long nr;
Chris Masone9d0b132007-08-10 14:06:19 -0400707
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400708 if (xchg(&root->defrag_running, 1))
Chris Masone9d0b132007-08-10 14:06:19 -0400709 return 0;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400710
Chris Mason6b800532007-10-15 16:17:34 -0400711 while (1) {
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400712 trans = btrfs_start_transaction(root, 0);
713 if (IS_ERR(trans))
714 return PTR_ERR(trans);
715
Chris Masone9d0b132007-08-10 14:06:19 -0400716 ret = btrfs_defrag_leaves(trans, root, cacheonly);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400717
Chris Masond3c2fdc2007-09-17 10:58:06 -0400718 nr = trans->blocks_used;
Chris Masone9d0b132007-08-10 14:06:19 -0400719 btrfs_end_transaction(trans, root);
Chris Masond3c2fdc2007-09-17 10:58:06 -0400720 btrfs_btree_balance_dirty(info->tree_root, nr);
Chris Masone9d0b132007-08-10 14:06:19 -0400721 cond_resched();
722
Chris Mason3f157a22008-06-25 16:01:31 -0400723 if (root->fs_info->closing || ret != -EAGAIN)
Chris Masone9d0b132007-08-10 14:06:19 -0400724 break;
725 }
726 root->defrag_running = 0;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400727 return ret;
Chris Masone9d0b132007-08-10 14:06:19 -0400728}
729
Yan Zheng2c47e6052009-06-27 21:07:35 -0400730#if 0
Chris Masond352ac62008-09-29 15:18:18 -0400731/*
Chris Masonb7ec40d2009-03-12 20:12:45 -0400732 * when dropping snapshots, we generate a ton of delayed refs, and it makes
733 * sense not to join the transaction while it is trying to flush the current
734 * queue of delayed refs out.
735 *
736 * This is used by the drop snapshot code only
737 */
738static noinline int wait_transaction_pre_flush(struct btrfs_fs_info *info)
739{
740 DEFINE_WAIT(wait);
741
742 mutex_lock(&info->trans_mutex);
743 while (info->running_transaction &&
744 info->running_transaction->delayed_refs.flushing) {
745 prepare_to_wait(&info->transaction_wait, &wait,
746 TASK_UNINTERRUPTIBLE);
747 mutex_unlock(&info->trans_mutex);
Chris Mason59bc5c72009-04-24 14:39:25 -0400748
Chris Masonb7ec40d2009-03-12 20:12:45 -0400749 schedule();
Chris Mason59bc5c72009-04-24 14:39:25 -0400750
Chris Masonb7ec40d2009-03-12 20:12:45 -0400751 mutex_lock(&info->trans_mutex);
752 finish_wait(&info->transaction_wait, &wait);
753 }
754 mutex_unlock(&info->trans_mutex);
755 return 0;
756}
757
758/*
Chris Masond352ac62008-09-29 15:18:18 -0400759 * Given a list of roots that need to be deleted, call btrfs_drop_snapshot on
760 * all of them
761 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400762int btrfs_drop_dead_root(struct btrfs_root *root)
Chris Mason0f7d52f2007-04-09 10:42:37 -0400763{
Chris Mason0f7d52f2007-04-09 10:42:37 -0400764 struct btrfs_trans_handle *trans;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400765 struct btrfs_root *tree_root = root->fs_info->tree_root;
Chris Masond3c2fdc2007-09-17 10:58:06 -0400766 unsigned long nr;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400767 int ret;
Chris Mason9f3a7422007-08-07 15:52:19 -0400768
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400769 while (1) {
770 /*
771 * we don't want to jump in and create a bunch of
772 * delayed refs if the transaction is starting to close
773 */
774 wait_transaction_pre_flush(tree_root->fs_info);
775 trans = btrfs_start_transaction(tree_root, 1);
Josef Bacik58176a92007-08-29 15:47:34 -0400776
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400777 /*
778 * we've joined a transaction, make sure it isn't
779 * closing right now
780 */
781 if (trans->transaction->delayed_refs.flushing) {
782 btrfs_end_transaction(trans, tree_root);
783 continue;
Josef Bacik58176a92007-08-29 15:47:34 -0400784 }
Chris Masona2135012008-06-25 16:01:30 -0400785
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400786 ret = btrfs_drop_snapshot(trans, root);
787 if (ret != -EAGAIN)
Chris Mason54aa1f42007-06-22 14:16:25 -0400788 break;
Chris Masona2135012008-06-25 16:01:30 -0400789
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400790 ret = btrfs_update_root(trans, tree_root,
791 &root->root_key,
792 &root->root_item);
793 if (ret)
794 break;
Yanbcc63ab2008-07-30 16:29:20 -0400795
Chris Masond3c2fdc2007-09-17 10:58:06 -0400796 nr = trans->blocks_used;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400797 ret = btrfs_end_transaction(trans, tree_root);
798 BUG_ON(ret);
Chris Mason5eda7b52007-06-22 14:16:25 -0400799
Chris Masond3c2fdc2007-09-17 10:58:06 -0400800 btrfs_btree_balance_dirty(tree_root, nr);
Chris Mason4dc11902007-10-15 16:18:14 -0400801 cond_resched();
Chris Mason0f7d52f2007-04-09 10:42:37 -0400802 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400803 BUG_ON(ret);
804
805 ret = btrfs_del_root(trans, tree_root, &root->root_key);
806 BUG_ON(ret);
807
808 nr = trans->blocks_used;
809 ret = btrfs_end_transaction(trans, tree_root);
810 BUG_ON(ret);
811
812 free_extent_buffer(root->node);
813 free_extent_buffer(root->commit_root);
814 kfree(root);
815
816 btrfs_btree_balance_dirty(tree_root, nr);
Chris Mason54aa1f42007-06-22 14:16:25 -0400817 return ret;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400818}
Yan Zheng2c47e6052009-06-27 21:07:35 -0400819#endif
Chris Mason0f7d52f2007-04-09 10:42:37 -0400820
Chris Masond352ac62008-09-29 15:18:18 -0400821/*
822 * new snapshots need to be created at a very specific time in the
823 * transaction commit. This does the actual creation
824 */
Chris Mason80b67942008-02-01 16:35:04 -0500825static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
Chris Mason3063d292008-01-08 15:46:30 -0500826 struct btrfs_fs_info *fs_info,
827 struct btrfs_pending_snapshot *pending)
828{
829 struct btrfs_key key;
Chris Mason80b67942008-02-01 16:35:04 -0500830 struct btrfs_root_item *new_root_item;
Chris Mason3063d292008-01-08 15:46:30 -0500831 struct btrfs_root *tree_root = fs_info->tree_root;
832 struct btrfs_root *root = pending->root;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000833 struct btrfs_root *parent_root;
834 struct inode *parent_inode;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400835 struct dentry *dentry;
Chris Mason3063d292008-01-08 15:46:30 -0500836 struct extent_buffer *tmp;
Chris Mason925baed2008-06-25 16:01:30 -0400837 struct extent_buffer *old;
Chris Mason3063d292008-01-08 15:46:30 -0500838 int ret;
Yan, Zhengd68fc572010-05-16 10:49:58 -0400839 int retries = 0;
840 u64 to_reserve = 0;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000841 u64 index = 0;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400842 u64 objectid;
Chris Mason3063d292008-01-08 15:46:30 -0500843
Chris Mason80b67942008-02-01 16:35:04 -0500844 new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
845 if (!new_root_item) {
Yan, Zhenga22285a2010-05-16 10:48:46 -0400846 pending->error = -ENOMEM;
Chris Mason80b67942008-02-01 16:35:04 -0500847 goto fail;
848 }
Yan, Zhenga22285a2010-05-16 10:48:46 -0400849
Chris Mason3063d292008-01-08 15:46:30 -0500850 ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400851 if (ret) {
852 pending->error = ret;
Chris Mason3063d292008-01-08 15:46:30 -0500853 goto fail;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400854 }
Chris Mason3063d292008-01-08 15:46:30 -0500855
Yan, Zheng3fd0a552010-05-16 10:49:59 -0400856 btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
Yan, Zhengd68fc572010-05-16 10:49:58 -0400857 btrfs_orphan_pre_snapshot(trans, pending, &to_reserve);
858
859 if (to_reserve > 0) {
860 ret = btrfs_block_rsv_add(trans, root, &pending->block_rsv,
861 to_reserve, &retries);
862 if (ret) {
863 pending->error = ret;
864 goto fail;
865 }
866 }
867
Chris Mason3063d292008-01-08 15:46:30 -0500868 key.objectid = objectid;
Yan, Zhenga22285a2010-05-16 10:48:46 -0400869 key.offset = (u64)-1;
870 key.type = BTRFS_ROOT_ITEM_KEY;
Chris Mason3063d292008-01-08 15:46:30 -0500871
Yan, Zhenga22285a2010-05-16 10:48:46 -0400872 trans->block_rsv = &pending->block_rsv;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000873
Yan, Zhenga22285a2010-05-16 10:48:46 -0400874 dentry = pending->dentry;
875 parent_inode = dentry->d_parent->d_inode;
876 parent_root = BTRFS_I(parent_inode)->root;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000877 record_root_in_trans(trans, parent_root);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400878
Sage Weil6bdb72d2010-03-15 17:27:13 +0000879 /*
880 * insert the directory item
881 */
Sage Weil6bdb72d2010-03-15 17:27:13 +0000882 ret = btrfs_set_inode_index(parent_inode, &index);
883 BUG_ON(ret);
884 ret = btrfs_insert_dir_item(trans, parent_root,
Yan, Zhenga22285a2010-05-16 10:48:46 -0400885 dentry->d_name.name, dentry->d_name.len,
886 parent_inode->i_ino, &key,
887 BTRFS_FT_DIR, index);
Sage Weil6bdb72d2010-03-15 17:27:13 +0000888 BUG_ON(ret);
889
Yan, Zhenga22285a2010-05-16 10:48:46 -0400890 btrfs_i_size_write(parent_inode, parent_inode->i_size +
891 dentry->d_name.len * 2);
Sage Weil6bdb72d2010-03-15 17:27:13 +0000892 ret = btrfs_update_inode(trans, parent_root, parent_inode);
893 BUG_ON(ret);
894
895 record_root_in_trans(trans, root);
896 btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
897 memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
898
Chris Mason925baed2008-06-25 16:01:30 -0400899 old = btrfs_lock_root_node(root);
Chris Mason9fa8cfe2009-03-13 10:24:59 -0400900 btrfs_cow_block(trans, root, old, NULL, 0, &old);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400901 btrfs_set_lock_blocking(old);
Chris Mason3063d292008-01-08 15:46:30 -0500902
Chris Mason925baed2008-06-25 16:01:30 -0400903 btrfs_copy_root(trans, root, old, &tmp, objectid);
904 btrfs_tree_unlock(old);
905 free_extent_buffer(old);
Chris Mason3063d292008-01-08 15:46:30 -0500906
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400907 btrfs_set_root_node(new_root_item, tmp);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400908 /* record when the snapshot was created in key.offset */
909 key.offset = trans->transid;
910 ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
Chris Mason925baed2008-06-25 16:01:30 -0400911 btrfs_tree_unlock(tmp);
Chris Mason3063d292008-01-08 15:46:30 -0500912 free_extent_buffer(tmp);
Chris Mason0660b5a2008-11-17 20:37:39 -0500913 BUG_ON(ret);
914
Yan, Zhenga22285a2010-05-16 10:48:46 -0400915 /*
916 * insert root back/forward references
917 */
918 ret = btrfs_add_root_ref(trans, tree_root, objectid,
919 parent_root->root_key.objectid,
920 parent_inode->i_ino, index,
921 dentry->d_name.name, dentry->d_name.len);
922 BUG_ON(ret);
923
924 key.offset = (u64)-1;
925 pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
926 BUG_ON(IS_ERR(pending->snap));
Yan, Zhengd68fc572010-05-16 10:49:58 -0400927
Yan, Zheng3fd0a552010-05-16 10:49:59 -0400928 btrfs_reloc_post_snapshot(trans, pending);
Yan, Zhengd68fc572010-05-16 10:49:58 -0400929 btrfs_orphan_post_snapshot(trans, pending);
Chris Mason3063d292008-01-08 15:46:30 -0500930fail:
Sage Weil6bdb72d2010-03-15 17:27:13 +0000931 kfree(new_root_item);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400932 btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
933 return 0;
Chris Mason3063d292008-01-08 15:46:30 -0500934}
935
Chris Masond352ac62008-09-29 15:18:18 -0400936/*
937 * create all the snapshots we've scheduled for creation
938 */
Chris Mason80b67942008-02-01 16:35:04 -0500939static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
940 struct btrfs_fs_info *fs_info)
Chris Mason3063d292008-01-08 15:46:30 -0500941{
942 struct btrfs_pending_snapshot *pending;
943 struct list_head *head = &trans->transaction->pending_snapshots;
Chris Mason3de45862008-11-17 21:02:50 -0500944 int ret;
945
Qinghuang Fengc6e30872009-01-21 10:59:08 -0500946 list_for_each_entry(pending, head, list) {
Chris Mason3de45862008-11-17 21:02:50 -0500947 ret = create_pending_snapshot(trans, fs_info, pending);
948 BUG_ON(ret);
949 }
950 return 0;
951}
952
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400953static void update_super_roots(struct btrfs_root *root)
954{
955 struct btrfs_root_item *root_item;
956 struct btrfs_super_block *super;
957
958 super = &root->fs_info->super_copy;
959
960 root_item = &root->fs_info->chunk_root->root_item;
961 super->chunk_root = root_item->bytenr;
962 super->chunk_root_generation = root_item->generation;
963 super->chunk_root_level = root_item->level;
964
965 root_item = &root->fs_info->tree_root->root_item;
966 super->root = root_item->bytenr;
967 super->generation = root_item->generation;
968 super->root_level = root_item->level;
969}
970
Chris Masonf36f3042009-07-30 10:04:48 -0400971int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
972{
973 int ret = 0;
974 spin_lock(&info->new_trans_lock);
975 if (info->running_transaction)
976 ret = info->running_transaction->in_commit;
977 spin_unlock(&info->new_trans_lock);
978 return ret;
979}
980
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400981int btrfs_transaction_blocked(struct btrfs_fs_info *info)
982{
983 int ret = 0;
984 spin_lock(&info->new_trans_lock);
985 if (info->running_transaction)
986 ret = info->running_transaction->blocked;
987 spin_unlock(&info->new_trans_lock);
988 return ret;
989}
990
Chris Mason79154b12007-03-22 15:59:16 -0400991int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
992 struct btrfs_root *root)
993{
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400994 unsigned long joined = 0;
995 unsigned long timeout = 1;
Chris Mason79154b12007-03-22 15:59:16 -0400996 struct btrfs_transaction *cur_trans;
Chris Mason8fd17792007-04-19 21:01:03 -0400997 struct btrfs_transaction *prev_trans = NULL;
Chris Mason79154b12007-03-22 15:59:16 -0400998 DEFINE_WAIT(wait);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400999 int ret;
Chris Mason89573b92009-03-12 20:12:45 -04001000 int should_grow = 0;
1001 unsigned long now = get_seconds();
Sage Weildccae992009-04-02 16:59:01 -04001002 int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
Chris Mason79154b12007-03-22 15:59:16 -04001003
Chris Mason5a3f23d2009-03-31 13:27:11 -04001004 btrfs_run_ordered_operations(root, 0);
1005
Chris Mason56bec292009-03-13 10:10:06 -04001006 /* make a pass through all the delayed refs we have so far
1007 * any runnings procs may add more while we are here
1008 */
1009 ret = btrfs_run_delayed_refs(trans, root, 0);
1010 BUG_ON(ret);
1011
Yan, Zhenga22285a2010-05-16 10:48:46 -04001012 btrfs_trans_release_metadata(trans, root);
1013
Chris Masonb7ec40d2009-03-12 20:12:45 -04001014 cur_trans = trans->transaction;
Chris Mason56bec292009-03-13 10:10:06 -04001015 /*
1016 * set the flushing flag so procs in this transaction have to
1017 * start sending their work down.
1018 */
Chris Masonb7ec40d2009-03-12 20:12:45 -04001019 cur_trans->delayed_refs.flushing = 1;
Chris Mason56bec292009-03-13 10:10:06 -04001020
Chris Masonc3e69d52009-03-13 10:17:05 -04001021 ret = btrfs_run_delayed_refs(trans, root, 0);
Chris Mason56bec292009-03-13 10:10:06 -04001022 BUG_ON(ret);
1023
Chris Mason79154b12007-03-22 15:59:16 -04001024 mutex_lock(&root->fs_info->trans_mutex);
Chris Masonb7ec40d2009-03-12 20:12:45 -04001025 if (cur_trans->in_commit) {
1026 cur_trans->use_count++;
Chris Masonccd467d2007-06-28 15:57:36 -04001027 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -04001028 btrfs_end_transaction(trans, root);
Chris Masonccd467d2007-06-28 15:57:36 -04001029
Chris Mason79154b12007-03-22 15:59:16 -04001030 ret = wait_for_commit(root, cur_trans);
1031 BUG_ON(ret);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001032
1033 mutex_lock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -04001034 put_transaction(cur_trans);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001035 mutex_unlock(&root->fs_info->trans_mutex);
1036
Chris Mason79154b12007-03-22 15:59:16 -04001037 return 0;
1038 }
Chris Mason4313b392008-01-03 09:08:48 -05001039
Chris Mason2c90e5d2007-04-02 10:50:19 -04001040 trans->transaction->in_commit = 1;
Chris Masonf9295742008-07-17 12:54:14 -04001041 trans->transaction->blocked = 1;
Chris Masonccd467d2007-06-28 15:57:36 -04001042 if (cur_trans->list.prev != &root->fs_info->trans_list) {
1043 prev_trans = list_entry(cur_trans->list.prev,
1044 struct btrfs_transaction, list);
1045 if (!prev_trans->commit_done) {
1046 prev_trans->use_count++;
Chris Masonccd467d2007-06-28 15:57:36 -04001047 mutex_unlock(&root->fs_info->trans_mutex);
1048
1049 wait_for_commit(root, prev_trans);
Chris Masonccd467d2007-06-28 15:57:36 -04001050
Chris Masonccd467d2007-06-28 15:57:36 -04001051 mutex_lock(&root->fs_info->trans_mutex);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001052 put_transaction(prev_trans);
Chris Masonccd467d2007-06-28 15:57:36 -04001053 }
1054 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001055
Chris Mason89573b92009-03-12 20:12:45 -04001056 if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
1057 should_grow = 1;
1058
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001059 do {
Yan Zheng7ea394f2008-08-05 13:05:02 -04001060 int snap_pending = 0;
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001061 joined = cur_trans->num_joined;
Yan Zheng7ea394f2008-08-05 13:05:02 -04001062 if (!list_empty(&trans->transaction->pending_snapshots))
1063 snap_pending = 1;
1064
Chris Mason2c90e5d2007-04-02 10:50:19 -04001065 WARN_ON(cur_trans != trans->transaction);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001066 if (cur_trans->num_writers > 1)
1067 timeout = MAX_SCHEDULE_TIMEOUT;
Chris Mason89573b92009-03-12 20:12:45 -04001068 else if (should_grow)
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001069 timeout = 1;
1070
Chris Mason79154b12007-03-22 15:59:16 -04001071 mutex_unlock(&root->fs_info->trans_mutex);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001072
Sage Weil0bdb1db2010-02-19 14:13:50 -08001073 if (flush_on_commit || snap_pending) {
Yan, Zheng24bbcf02009-11-12 09:36:34 +00001074 btrfs_start_delalloc_inodes(root, 1);
1075 ret = btrfs_wait_ordered_extents(root, 0, 1);
Sage Weilebecd3d2009-07-24 13:17:44 -04001076 BUG_ON(ret);
Yan Zheng7ea394f2008-08-05 13:05:02 -04001077 }
1078
Chris Mason5a3f23d2009-03-31 13:27:11 -04001079 /*
1080 * rename don't use btrfs_join_transaction, so, once we
1081 * set the transaction to blocked above, we aren't going
1082 * to get any new ordered operations. We can safely run
1083 * it here and no for sure that nothing new will be added
1084 * to the list
1085 */
1086 btrfs_run_ordered_operations(root, 1);
1087
Chris Masoned3b3d3142010-05-25 10:12:41 -04001088 prepare_to_wait(&cur_trans->writer_wait, &wait,
1089 TASK_UNINTERRUPTIBLE);
1090
Chris Mason89573b92009-03-12 20:12:45 -04001091 smp_mb();
1092 if (cur_trans->num_writers > 1 || should_grow)
1093 schedule_timeout(timeout);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001094
Chris Mason79154b12007-03-22 15:59:16 -04001095 mutex_lock(&root->fs_info->trans_mutex);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001096 finish_wait(&cur_trans->writer_wait, &wait);
1097 } while (cur_trans->num_writers > 1 ||
Chris Mason89573b92009-03-12 20:12:45 -04001098 (should_grow && cur_trans->num_joined != joined));
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001099
Chris Mason3063d292008-01-08 15:46:30 -05001100 ret = create_pending_snapshots(trans, root->fs_info);
1101 BUG_ON(ret);
1102
Chris Mason56bec292009-03-13 10:10:06 -04001103 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1104 BUG_ON(ret);
1105
Chris Mason2c90e5d2007-04-02 10:50:19 -04001106 WARN_ON(cur_trans != trans->transaction);
Chris Masondc17ff82008-01-08 15:46:30 -05001107
Chris Masone02119d2008-09-05 16:13:11 -04001108 /* btrfs_commit_tree_roots is responsible for getting the
1109 * various roots consistent with each other. Every pointer
1110 * in the tree of tree roots has to point to the most up to date
1111 * root for every subvolume and other tree. So, we have to keep
1112 * the tree logging code from jumping in and changing any
1113 * of the trees.
1114 *
1115 * At this point in the commit, there can't be any tree-log
1116 * writers, but a little lower down we drop the trans mutex
1117 * and let new people in. By holding the tree_log_mutex
1118 * from now until after the super is written, we avoid races
1119 * with the tree-log code.
1120 */
1121 mutex_lock(&root->fs_info->tree_log_mutex);
Zheng Yan1a40e232008-09-26 10:09:34 -04001122
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001123 ret = commit_fs_roots(trans, root);
Chris Mason54aa1f42007-06-22 14:16:25 -04001124 BUG_ON(ret);
1125
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001126 /* commit_fs_roots gets rid of all the tree log roots, it is now
Chris Masone02119d2008-09-05 16:13:11 -04001127 * safe to free the root of tree log roots
1128 */
1129 btrfs_free_log_root_tree(trans, root->fs_info);
1130
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001131 ret = commit_cowonly_roots(trans, root);
Chris Mason79154b12007-03-22 15:59:16 -04001132 BUG_ON(ret);
Chris Mason54aa1f42007-06-22 14:16:25 -04001133
Yan Zheng11833d62009-09-11 16:11:19 -04001134 btrfs_prepare_extent_commit(trans, root);
1135
Chris Mason78fae272007-03-25 11:35:08 -04001136 cur_trans = root->fs_info->running_transaction;
Chris Masoncee36a02008-01-15 08:40:48 -05001137 spin_lock(&root->fs_info->new_trans_lock);
Chris Mason78fae272007-03-25 11:35:08 -04001138 root->fs_info->running_transaction = NULL;
Chris Masoncee36a02008-01-15 08:40:48 -05001139 spin_unlock(&root->fs_info->new_trans_lock);
Chris Mason5f39d392007-10-15 16:14:19 -04001140
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001141 btrfs_set_root_node(&root->fs_info->tree_root->root_item,
1142 root->fs_info->tree_root->node);
Josef Bacik817d52f2009-07-13 21:29:25 -04001143 switch_commit_root(root->fs_info->tree_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001144
1145 btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
1146 root->fs_info->chunk_root->node);
Josef Bacik817d52f2009-07-13 21:29:25 -04001147 switch_commit_root(root->fs_info->chunk_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001148
1149 update_super_roots(root);
Chris Masone02119d2008-09-05 16:13:11 -04001150
1151 if (!root->fs_info->log_root_recovering) {
1152 btrfs_set_super_log_root(&root->fs_info->super_copy, 0);
1153 btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0);
1154 }
1155
Chris Masona061fc82008-05-07 11:43:44 -04001156 memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
1157 sizeof(root->fs_info->super_copy));
Chris Masonccd467d2007-06-28 15:57:36 -04001158
Chris Masonf9295742008-07-17 12:54:14 -04001159 trans->transaction->blocked = 0;
Chris Masonb7ec40d2009-03-12 20:12:45 -04001160
Chris Masonf9295742008-07-17 12:54:14 -04001161 wake_up(&root->fs_info->transaction_wait);
Chris Masone6dcd2d2008-07-17 12:53:50 -04001162
Chris Mason78fae272007-03-25 11:35:08 -04001163 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -04001164 ret = btrfs_write_and_wait_transaction(trans, root);
1165 BUG_ON(ret);
Yan Zhenga512bbf2008-12-08 16:46:26 -05001166 write_ctree_super(trans, root, 0);
Chris Mason4313b392008-01-03 09:08:48 -05001167
Chris Masone02119d2008-09-05 16:13:11 -04001168 /*
1169 * the super is written, we can safely allow the tree-loggers
1170 * to go about their business
1171 */
1172 mutex_unlock(&root->fs_info->tree_log_mutex);
1173
Yan Zheng11833d62009-09-11 16:11:19 -04001174 btrfs_finish_extent_commit(trans, root);
Chris Mason4313b392008-01-03 09:08:48 -05001175
Zheng Yan1a40e232008-09-26 10:09:34 -04001176 mutex_lock(&root->fs_info->trans_mutex);
1177
Chris Mason2c90e5d2007-04-02 10:50:19 -04001178 cur_trans->commit_done = 1;
Chris Masonb7ec40d2009-03-12 20:12:45 -04001179
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001180 root->fs_info->last_trans_committed = cur_trans->transid;
Josef Bacik817d52f2009-07-13 21:29:25 -04001181
Chris Mason2c90e5d2007-04-02 10:50:19 -04001182 wake_up(&cur_trans->commit_wait);
Chris Mason3de45862008-11-17 21:02:50 -05001183
Chris Mason79154b12007-03-22 15:59:16 -04001184 put_transaction(cur_trans);
Chris Mason78fae272007-03-25 11:35:08 -04001185 put_transaction(cur_trans);
Josef Bacik58176a92007-08-29 15:47:34 -04001186
Chris Mason78fae272007-03-25 11:35:08 -04001187 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason3de45862008-11-17 21:02:50 -05001188
Josef Bacik9ed74f22009-09-11 16:12:44 -04001189 if (current->journal_info == trans)
1190 current->journal_info = NULL;
1191
Chris Mason2c90e5d2007-04-02 10:50:19 -04001192 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Yan, Zheng24bbcf02009-11-12 09:36:34 +00001193
1194 if (current != root->fs_info->transaction_kthread)
1195 btrfs_run_delayed_iputs(root);
1196
Chris Mason79154b12007-03-22 15:59:16 -04001197 return ret;
1198}
1199
Chris Masond352ac62008-09-29 15:18:18 -04001200/*
1201 * interface function to delete all the snapshots we have scheduled for deletion
1202 */
Chris Masone9d0b132007-08-10 14:06:19 -04001203int btrfs_clean_old_snapshots(struct btrfs_root *root)
1204{
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001205 LIST_HEAD(list);
1206 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Masone9d0b132007-08-10 14:06:19 -04001207
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001208 mutex_lock(&fs_info->trans_mutex);
1209 list_splice_init(&fs_info->dead_roots, &list);
1210 mutex_unlock(&fs_info->trans_mutex);
1211
1212 while (!list_empty(&list)) {
1213 root = list_entry(list.next, struct btrfs_root, root_list);
Yan, Zheng76dda932009-09-21 16:00:26 -04001214 list_del(&root->root_list);
1215
1216 if (btrfs_header_backref_rev(root->node) <
1217 BTRFS_MIXED_BACKREF_REV)
Yan, Zheng3fd0a552010-05-16 10:49:59 -04001218 btrfs_drop_snapshot(root, NULL, 0);
Yan, Zheng76dda932009-09-21 16:00:26 -04001219 else
Yan, Zheng3fd0a552010-05-16 10:49:59 -04001220 btrfs_drop_snapshot(root, NULL, 1);
Chris Masone9d0b132007-08-10 14:06:19 -04001221 }
1222 return 0;
1223}