blob: 2cb116099b90207d0f1910176de8a029bd23c93f [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
Chris Masone02119d2008-09-05 16:13:11 -0400168static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
Josef Bacik249ac1e2009-11-10 21:23:48 -0500169 int num_blocks, int type)
Chris Mason37d1aee2008-07-31 10:48:37 -0400170{
171 struct btrfs_trans_handle *h =
172 kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
173 int ret;
174
175 mutex_lock(&root->fs_info->trans_mutex);
Chris Mason4bef0842008-09-08 11:18:08 -0400176 if (!root->fs_info->log_root_recovering &&
Josef Bacik249ac1e2009-11-10 21:23:48 -0500177 ((type == TRANS_START && !root->fs_info->open_ioctl_trans) ||
178 type == TRANS_USERSPACE))
Chris Mason37d1aee2008-07-31 10:48:37 -0400179 wait_current_trans(root);
Chris Mason79154b12007-03-22 15:59:16 -0400180 ret = join_transaction(root);
181 BUG_ON(ret);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400182
Chris Mason6702ed42007-08-07 16:15:09 -0400183 h->transid = root->fs_info->running_transaction->transid;
Chris Mason79154b12007-03-22 15:59:16 -0400184 h->transaction = root->fs_info->running_transaction;
185 h->blocks_reserved = num_blocks;
186 h->blocks_used = 0;
Yan Zhengd2fb3432008-12-11 16:30:39 -0500187 h->block_group = 0;
Chris Mason26b80032007-08-08 20:17:12 -0400188 h->alloc_exclude_nr = 0;
189 h->alloc_exclude_start = 0;
Chris Mason56bec292009-03-13 10:10:06 -0400190 h->delayed_ref_updates = 0;
Chris Masonb7ec40d2009-03-12 20:12:45 -0400191
Josef Bacik249ac1e2009-11-10 21:23:48 -0500192 if (!current->journal_info && type != TRANS_USERSPACE)
Josef Bacik9ed74f22009-09-11 16:12:44 -0400193 current->journal_info = h;
194
Chris Mason79154b12007-03-22 15:59:16 -0400195 root->fs_info->running_transaction->use_count++;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400196 record_root_in_trans(h, root);
Chris Mason79154b12007-03-22 15:59:16 -0400197 mutex_unlock(&root->fs_info->trans_mutex);
198 return h;
199}
200
Chris Masonf9295742008-07-17 12:54:14 -0400201struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
202 int num_blocks)
203{
Josef Bacik249ac1e2009-11-10 21:23:48 -0500204 return start_transaction(root, num_blocks, TRANS_START);
Chris Masonf9295742008-07-17 12:54:14 -0400205}
206struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root,
207 int num_blocks)
208{
Josef Bacik249ac1e2009-11-10 21:23:48 -0500209 return start_transaction(root, num_blocks, TRANS_JOIN);
Chris Masonf9295742008-07-17 12:54:14 -0400210}
211
Sage Weil9ca9ee02008-08-04 10:41:27 -0400212struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r,
213 int num_blocks)
214{
Josef Bacik249ac1e2009-11-10 21:23:48 -0500215 return start_transaction(r, num_blocks, TRANS_USERSPACE);
Sage Weil9ca9ee02008-08-04 10:41:27 -0400216}
217
Chris Masond352ac62008-09-29 15:18:18 -0400218/* wait for a transaction commit to be fully complete */
Chris Mason89ce8a62008-06-25 16:01:31 -0400219static noinline int wait_for_commit(struct btrfs_root *root,
220 struct btrfs_transaction *commit)
221{
222 DEFINE_WAIT(wait);
223 mutex_lock(&root->fs_info->trans_mutex);
Chris Masond3977122009-01-05 21:25:51 -0500224 while (!commit->commit_done) {
Chris Mason89ce8a62008-06-25 16:01:31 -0400225 prepare_to_wait(&commit->commit_wait, &wait,
226 TASK_UNINTERRUPTIBLE);
227 if (commit->commit_done)
228 break;
229 mutex_unlock(&root->fs_info->trans_mutex);
230 schedule();
231 mutex_lock(&root->fs_info->trans_mutex);
232 }
233 mutex_unlock(&root->fs_info->trans_mutex);
234 finish_wait(&commit->commit_wait, &wait);
235 return 0;
236}
237
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400238#if 0
Chris Masond352ac62008-09-29 15:18:18 -0400239/*
Chris Masond3977122009-01-05 21:25:51 -0500240 * rate limit against the drop_snapshot code. This helps to slow down new
241 * operations if the drop_snapshot code isn't able to keep up.
Chris Masond352ac62008-09-29 15:18:18 -0400242 */
Chris Mason37d1aee2008-07-31 10:48:37 -0400243static void throttle_on_drops(struct btrfs_root *root)
Chris Masonab78c842008-07-29 16:15:18 -0400244{
245 struct btrfs_fs_info *info = root->fs_info;
Chris Mason2dd3e672008-08-04 08:20:15 -0400246 int harder_count = 0;
Chris Masonab78c842008-07-29 16:15:18 -0400247
Chris Mason2dd3e672008-08-04 08:20:15 -0400248harder:
Chris Masonab78c842008-07-29 16:15:18 -0400249 if (atomic_read(&info->throttles)) {
250 DEFINE_WAIT(wait);
251 int thr;
Chris Masonab78c842008-07-29 16:15:18 -0400252 thr = atomic_read(&info->throttle_gen);
253
254 do {
255 prepare_to_wait(&info->transaction_throttle,
256 &wait, TASK_UNINTERRUPTIBLE);
257 if (!atomic_read(&info->throttles)) {
258 finish_wait(&info->transaction_throttle, &wait);
259 break;
260 }
261 schedule();
262 finish_wait(&info->transaction_throttle, &wait);
263 } while (thr == atomic_read(&info->throttle_gen));
Chris Mason2dd3e672008-08-04 08:20:15 -0400264 harder_count++;
265
266 if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 &&
267 harder_count < 2)
268 goto harder;
269
270 if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 &&
271 harder_count < 10)
272 goto harder;
273
274 if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 &&
275 harder_count < 20)
276 goto harder;
Chris Masonab78c842008-07-29 16:15:18 -0400277 }
278}
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400279#endif
Chris Masonab78c842008-07-29 16:15:18 -0400280
Chris Mason37d1aee2008-07-31 10:48:37 -0400281void btrfs_throttle(struct btrfs_root *root)
282{
283 mutex_lock(&root->fs_info->trans_mutex);
Sage Weil9ca9ee02008-08-04 10:41:27 -0400284 if (!root->fs_info->open_ioctl_trans)
285 wait_current_trans(root);
Chris Mason37d1aee2008-07-31 10:48:37 -0400286 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason37d1aee2008-07-31 10:48:37 -0400287}
288
Chris Mason89ce8a62008-06-25 16:01:31 -0400289static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
290 struct btrfs_root *root, int throttle)
Chris Mason79154b12007-03-22 15:59:16 -0400291{
292 struct btrfs_transaction *cur_trans;
Chris Masonab78c842008-07-29 16:15:18 -0400293 struct btrfs_fs_info *info = root->fs_info;
Chris Masonc3e69d52009-03-13 10:17:05 -0400294 int count = 0;
Chris Masond6e4a422007-04-06 15:37:36 -0400295
Chris Masonc3e69d52009-03-13 10:17:05 -0400296 while (count < 4) {
297 unsigned long cur = trans->delayed_ref_updates;
298 trans->delayed_ref_updates = 0;
299 if (cur &&
300 trans->transaction->delayed_refs.num_heads_ready > 64) {
301 trans->delayed_ref_updates = 0;
Chris Masonb7ec40d2009-03-12 20:12:45 -0400302
303 /*
304 * do a full flush if the transaction is trying
305 * to close
306 */
307 if (trans->transaction->delayed_refs.flushing)
308 cur = 0;
Chris Masonc3e69d52009-03-13 10:17:05 -0400309 btrfs_run_delayed_refs(trans, root, cur);
310 } else {
311 break;
312 }
313 count++;
Chris Mason56bec292009-03-13 10:10:06 -0400314 }
315
Chris Masonab78c842008-07-29 16:15:18 -0400316 mutex_lock(&info->trans_mutex);
317 cur_trans = info->running_transaction;
Chris Masonccd467d2007-06-28 15:57:36 -0400318 WARN_ON(cur_trans != trans->transaction);
Chris Masond5719762007-03-23 10:01:08 -0400319 WARN_ON(cur_trans->num_writers < 1);
Chris Masonccd467d2007-06-28 15:57:36 -0400320 cur_trans->num_writers--;
Chris Mason89ce8a62008-06-25 16:01:31 -0400321
Chris Mason79154b12007-03-22 15:59:16 -0400322 if (waitqueue_active(&cur_trans->writer_wait))
323 wake_up(&cur_trans->writer_wait);
Chris Mason79154b12007-03-22 15:59:16 -0400324 put_transaction(cur_trans);
Chris Masonab78c842008-07-29 16:15:18 -0400325 mutex_unlock(&info->trans_mutex);
Josef Bacik9ed74f22009-09-11 16:12:44 -0400326
327 if (current->journal_info == trans)
328 current->journal_info = NULL;
Chris Masond6025572007-03-30 14:27:56 -0400329 memset(trans, 0, sizeof(*trans));
Chris Mason2c90e5d2007-04-02 10:50:19 -0400330 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Chris Masonab78c842008-07-29 16:15:18 -0400331
Yan, Zheng24bbcf02009-11-12 09:36:34 +0000332 if (throttle)
333 btrfs_run_delayed_iputs(root);
334
Chris Mason79154b12007-03-22 15:59:16 -0400335 return 0;
336}
337
Chris Mason89ce8a62008-06-25 16:01:31 -0400338int btrfs_end_transaction(struct btrfs_trans_handle *trans,
339 struct btrfs_root *root)
340{
341 return __btrfs_end_transaction(trans, root, 0);
342}
343
344int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
345 struct btrfs_root *root)
346{
347 return __btrfs_end_transaction(trans, root, 1);
348}
349
Chris Masond352ac62008-09-29 15:18:18 -0400350/*
351 * when btree blocks are allocated, they have some corresponding bits set for
352 * them in one of two extent_io trees. This is used to make sure all of
Chris Mason690587d2009-10-13 13:29:19 -0400353 * those extents are sent to disk but does not wait on them
Chris Masond352ac62008-09-29 15:18:18 -0400354 */
Chris Mason690587d2009-10-13 13:29:19 -0400355int btrfs_write_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000356 struct extent_io_tree *dirty_pages, int mark)
Chris Mason79154b12007-03-22 15:59:16 -0400357{
Chris Mason7c4452b2007-04-28 09:29:35 -0400358 int ret;
Chris Mason777e6bd2008-08-15 15:34:15 -0400359 int err = 0;
Chris Mason7c4452b2007-04-28 09:29:35 -0400360 int werr = 0;
361 struct page *page;
Chris Mason7c4452b2007-04-28 09:29:35 -0400362 struct inode *btree_inode = root->fs_info->btree_inode;
Chris Mason777e6bd2008-08-15 15:34:15 -0400363 u64 start = 0;
Chris Mason5f39d392007-10-15 16:14:19 -0400364 u64 end;
365 unsigned long index;
Chris Mason7c4452b2007-04-28 09:29:35 -0400366
Chris Masond3977122009-01-05 21:25:51 -0500367 while (1) {
Chris Mason777e6bd2008-08-15 15:34:15 -0400368 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000369 mark);
Chris Mason5f39d392007-10-15 16:14:19 -0400370 if (ret)
Chris Mason7c4452b2007-04-28 09:29:35 -0400371 break;
Chris Masond3977122009-01-05 21:25:51 -0500372 while (start <= end) {
Chris Mason777e6bd2008-08-15 15:34:15 -0400373 cond_resched();
374
Chris Mason5f39d392007-10-15 16:14:19 -0400375 index = start >> PAGE_CACHE_SHIFT;
Chris Mason35ebb932007-10-30 16:56:53 -0400376 start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
Chris Mason4bef0842008-09-08 11:18:08 -0400377 page = find_get_page(btree_inode->i_mapping, index);
Chris Mason7c4452b2007-04-28 09:29:35 -0400378 if (!page)
379 continue;
Chris Mason4bef0842008-09-08 11:18:08 -0400380
381 btree_lock_page_hook(page);
382 if (!page->mapping) {
383 unlock_page(page);
384 page_cache_release(page);
385 continue;
386 }
387
Chris Mason6702ed42007-08-07 16:15:09 -0400388 if (PageWriteback(page)) {
389 if (PageDirty(page))
390 wait_on_page_writeback(page);
391 else {
392 unlock_page(page);
393 page_cache_release(page);
394 continue;
395 }
396 }
Chris Mason7c4452b2007-04-28 09:29:35 -0400397 err = write_one_page(page, 0);
398 if (err)
399 werr = err;
400 page_cache_release(page);
401 }
402 }
Chris Mason690587d2009-10-13 13:29:19 -0400403 if (err)
404 werr = err;
405 return werr;
406}
407
408/*
409 * when btree blocks are allocated, they have some corresponding bits set for
410 * them in one of two extent_io trees. This is used to make sure all of
411 * those extents are on disk for transaction or log commit. We wait
412 * on all the pages and clear them from the dirty pages state tree
413 */
414int btrfs_wait_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000415 struct extent_io_tree *dirty_pages, int mark)
Chris Mason690587d2009-10-13 13:29:19 -0400416{
417 int ret;
418 int err = 0;
419 int werr = 0;
420 struct page *page;
421 struct inode *btree_inode = root->fs_info->btree_inode;
422 u64 start = 0;
423 u64 end;
424 unsigned long index;
425
Chris Masond3977122009-01-05 21:25:51 -0500426 while (1) {
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000427 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
428 mark);
Chris Mason777e6bd2008-08-15 15:34:15 -0400429 if (ret)
430 break;
431
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000432 clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
Chris Masond3977122009-01-05 21:25:51 -0500433 while (start <= end) {
Chris Mason777e6bd2008-08-15 15:34:15 -0400434 index = start >> PAGE_CACHE_SHIFT;
435 start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
436 page = find_get_page(btree_inode->i_mapping, index);
437 if (!page)
438 continue;
439 if (PageDirty(page)) {
Chris Mason4bef0842008-09-08 11:18:08 -0400440 btree_lock_page_hook(page);
441 wait_on_page_writeback(page);
Chris Mason777e6bd2008-08-15 15:34:15 -0400442 err = write_one_page(page, 0);
443 if (err)
444 werr = err;
445 }
Chris Mason105d9312008-11-18 12:13:12 -0500446 wait_on_page_writeback(page);
Chris Mason777e6bd2008-08-15 15:34:15 -0400447 page_cache_release(page);
448 cond_resched();
449 }
450 }
Chris Mason7c4452b2007-04-28 09:29:35 -0400451 if (err)
452 werr = err;
453 return werr;
Chris Mason79154b12007-03-22 15:59:16 -0400454}
455
Chris Mason690587d2009-10-13 13:29:19 -0400456/*
457 * when btree blocks are allocated, they have some corresponding bits set for
458 * them in one of two extent_io trees. This is used to make sure all of
459 * those extents are on disk for transaction or log commit
460 */
461int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000462 struct extent_io_tree *dirty_pages, int mark)
Chris Mason690587d2009-10-13 13:29:19 -0400463{
464 int ret;
465 int ret2;
466
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000467 ret = btrfs_write_marked_extents(root, dirty_pages, mark);
468 ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
Chris Mason690587d2009-10-13 13:29:19 -0400469 return ret || ret2;
470}
471
Chris Masond0c803c2008-09-11 16:17:57 -0400472int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
473 struct btrfs_root *root)
474{
475 if (!trans || !trans->transaction) {
476 struct inode *btree_inode;
477 btree_inode = root->fs_info->btree_inode;
478 return filemap_write_and_wait(btree_inode->i_mapping);
479 }
480 return btrfs_write_and_wait_marked_extents(root,
Yan, Zheng8cef4e12009-11-12 09:33:26 +0000481 &trans->transaction->dirty_pages,
482 EXTENT_DIRTY);
Chris Masond0c803c2008-09-11 16:17:57 -0400483}
484
Chris Masond352ac62008-09-29 15:18:18 -0400485/*
486 * this is used to update the root pointer in the tree of tree roots.
487 *
488 * But, in the case of the extent allocation tree, updating the root
489 * pointer may allocate blocks which may change the root of the extent
490 * allocation tree.
491 *
492 * So, this loops and repeats and makes sure the cowonly root didn't
493 * change while the root pointer was being updated in the metadata.
494 */
Chris Mason0b86a832008-03-24 15:01:56 -0400495static int update_cowonly_root(struct btrfs_trans_handle *trans,
496 struct btrfs_root *root)
497{
498 int ret;
499 u64 old_root_bytenr;
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000500 u64 old_root_used;
Chris Mason0b86a832008-03-24 15:01:56 -0400501 struct btrfs_root *tree_root = root->fs_info->tree_root;
502
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000503 old_root_used = btrfs_root_used(&root->root_item);
Chris Mason0b86a832008-03-24 15:01:56 -0400504 btrfs_write_dirty_block_groups(trans, root);
Chris Mason56bec292009-03-13 10:10:06 -0400505
Chris Masond3977122009-01-05 21:25:51 -0500506 while (1) {
Chris Mason0b86a832008-03-24 15:01:56 -0400507 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000508 if (old_root_bytenr == root->node->start &&
509 old_root_used == btrfs_root_used(&root->root_item))
Chris Mason0b86a832008-03-24 15:01:56 -0400510 break;
Chris Mason87ef2bb2008-10-30 11:23:27 -0400511
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400512 btrfs_set_root_node(&root->root_item, root->node);
Chris Mason0b86a832008-03-24 15:01:56 -0400513 ret = btrfs_update_root(trans, tree_root,
514 &root->root_key,
515 &root->root_item);
516 BUG_ON(ret);
Chris Mason56bec292009-03-13 10:10:06 -0400517
Yan, Zheng86b9f2e2009-11-12 09:36:50 +0000518 old_root_used = btrfs_root_used(&root->root_item);
Yan Zheng4a8c9a62009-07-22 10:07:05 -0400519 ret = btrfs_write_dirty_block_groups(trans, root);
Chris Mason56bec292009-03-13 10:10:06 -0400520 BUG_ON(ret);
Chris Mason0b86a832008-03-24 15:01:56 -0400521 }
Yan Zheng276e6802009-07-30 09:40:40 -0400522
523 if (root != root->fs_info->extent_root)
524 switch_commit_root(root);
525
Chris Mason0b86a832008-03-24 15:01:56 -0400526 return 0;
527}
528
Chris Masond352ac62008-09-29 15:18:18 -0400529/*
530 * update all the cowonly tree roots on disk
531 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400532static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
533 struct btrfs_root *root)
Chris Mason79154b12007-03-22 15:59:16 -0400534{
Chris Mason79154b12007-03-22 15:59:16 -0400535 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Mason0b86a832008-03-24 15:01:56 -0400536 struct list_head *next;
Yan Zheng84234f32008-10-29 14:49:05 -0400537 struct extent_buffer *eb;
Chris Mason56bec292009-03-13 10:10:06 -0400538 int ret;
Yan Zheng84234f32008-10-29 14:49:05 -0400539
Chris Mason56bec292009-03-13 10:10:06 -0400540 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
541 BUG_ON(ret);
Chris Mason87ef2bb2008-10-30 11:23:27 -0400542
Yan Zheng84234f32008-10-29 14:49:05 -0400543 eb = btrfs_lock_root_node(fs_info->tree_root);
Chris Mason9fa8cfe2009-03-13 10:24:59 -0400544 btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
Yan Zheng84234f32008-10-29 14:49:05 -0400545 btrfs_tree_unlock(eb);
546 free_extent_buffer(eb);
Chris Mason79154b12007-03-22 15:59:16 -0400547
Chris Mason56bec292009-03-13 10:10:06 -0400548 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
549 BUG_ON(ret);
Chris Mason87ef2bb2008-10-30 11:23:27 -0400550
Chris Masond3977122009-01-05 21:25:51 -0500551 while (!list_empty(&fs_info->dirty_cowonly_roots)) {
Chris Mason0b86a832008-03-24 15:01:56 -0400552 next = fs_info->dirty_cowonly_roots.next;
553 list_del_init(next);
554 root = list_entry(next, struct btrfs_root, dirty_list);
Chris Mason87ef2bb2008-10-30 11:23:27 -0400555
Chris Mason0b86a832008-03-24 15:01:56 -0400556 update_cowonly_root(trans, root);
Chris Mason79154b12007-03-22 15:59:16 -0400557 }
Yan Zheng276e6802009-07-30 09:40:40 -0400558
559 down_write(&fs_info->extent_commit_sem);
560 switch_commit_root(fs_info->extent_root);
561 up_write(&fs_info->extent_commit_sem);
562
Chris Mason79154b12007-03-22 15:59:16 -0400563 return 0;
564}
565
Chris Masond352ac62008-09-29 15:18:18 -0400566/*
567 * dead roots are old snapshots that need to be deleted. This allocates
568 * a dirty root struct and adds it into the list of dead roots that need to
569 * be deleted
570 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400571int btrfs_add_dead_root(struct btrfs_root *root)
Chris Mason5eda7b52007-06-22 14:16:25 -0400572{
Yan Zhengb48652c2008-08-04 23:23:47 -0400573 mutex_lock(&root->fs_info->trans_mutex);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400574 list_add(&root->root_list, &root->fs_info->dead_roots);
Yan Zhengb48652c2008-08-04 23:23:47 -0400575 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason5eda7b52007-06-22 14:16:25 -0400576 return 0;
577}
578
Chris Masond352ac62008-09-29 15:18:18 -0400579/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400580 * update all the cowonly tree roots on disk
Chris Masond352ac62008-09-29 15:18:18 -0400581 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400582static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
583 struct btrfs_root *root)
Chris Mason0f7d52f2007-04-09 10:42:37 -0400584{
Chris Mason0f7d52f2007-04-09 10:42:37 -0400585 struct btrfs_root *gang[8];
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400586 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400587 int i;
588 int ret;
Chris Mason54aa1f42007-06-22 14:16:25 -0400589 int err = 0;
590
Chris Masond3977122009-01-05 21:25:51 -0500591 while (1) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400592 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
593 (void **)gang, 0,
Chris Mason0f7d52f2007-04-09 10:42:37 -0400594 ARRAY_SIZE(gang),
595 BTRFS_ROOT_TRANS_TAG);
596 if (ret == 0)
597 break;
598 for (i = 0; i < ret; i++) {
599 root = gang[i];
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400600 radix_tree_tag_clear(&fs_info->fs_roots_radix,
601 (unsigned long)root->root_key.objectid,
602 BTRFS_ROOT_TRANS_TAG);
Yan Zheng31153d82008-07-28 15:32:19 -0400603
Chris Masone02119d2008-09-05 16:13:11 -0400604 btrfs_free_log(trans, root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400605 btrfs_update_reloc_root(trans, root);
Chris Masone02119d2008-09-05 16:13:11 -0400606
Yan Zheng978d9102009-06-15 20:01:02 -0400607 if (root->commit_root != root->node) {
Josef Bacik817d52f2009-07-13 21:29:25 -0400608 switch_commit_root(root);
Yan Zheng978d9102009-06-15 20:01:02 -0400609 btrfs_set_root_node(&root->root_item,
610 root->node);
611 }
Chris Mason9f3a7422007-08-07 15:52:19 -0400612
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400613 err = btrfs_update_root(trans, fs_info->tree_root,
Chris Mason0f7d52f2007-04-09 10:42:37 -0400614 &root->root_key,
615 &root->root_item);
Chris Mason54aa1f42007-06-22 14:16:25 -0400616 if (err)
617 break;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400618 }
619 }
Chris Mason54aa1f42007-06-22 14:16:25 -0400620 return err;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400621}
622
Chris Masond352ac62008-09-29 15:18:18 -0400623/*
624 * defrag a given btree. If cacheonly == 1, this won't read from the disk,
625 * otherwise every leaf in the btree is read and defragged.
626 */
Chris Masone9d0b132007-08-10 14:06:19 -0400627int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
628{
629 struct btrfs_fs_info *info = root->fs_info;
630 int ret;
631 struct btrfs_trans_handle *trans;
Chris Masond3c2fdc2007-09-17 10:58:06 -0400632 unsigned long nr;
Chris Masone9d0b132007-08-10 14:06:19 -0400633
Chris Masona2135012008-06-25 16:01:30 -0400634 smp_mb();
Chris Masone9d0b132007-08-10 14:06:19 -0400635 if (root->defrag_running)
636 return 0;
Chris Masone9d0b132007-08-10 14:06:19 -0400637 trans = btrfs_start_transaction(root, 1);
Chris Mason6b800532007-10-15 16:17:34 -0400638 while (1) {
Chris Masone9d0b132007-08-10 14:06:19 -0400639 root->defrag_running = 1;
640 ret = btrfs_defrag_leaves(trans, root, cacheonly);
Chris Masond3c2fdc2007-09-17 10:58:06 -0400641 nr = trans->blocks_used;
Chris Masone9d0b132007-08-10 14:06:19 -0400642 btrfs_end_transaction(trans, root);
Chris Masond3c2fdc2007-09-17 10:58:06 -0400643 btrfs_btree_balance_dirty(info->tree_root, nr);
Chris Masone9d0b132007-08-10 14:06:19 -0400644 cond_resched();
645
Chris Masone9d0b132007-08-10 14:06:19 -0400646 trans = btrfs_start_transaction(root, 1);
Chris Mason3f157a22008-06-25 16:01:31 -0400647 if (root->fs_info->closing || ret != -EAGAIN)
Chris Masone9d0b132007-08-10 14:06:19 -0400648 break;
649 }
650 root->defrag_running = 0;
Chris Masona2135012008-06-25 16:01:30 -0400651 smp_mb();
Chris Masone9d0b132007-08-10 14:06:19 -0400652 btrfs_end_transaction(trans, root);
653 return 0;
654}
655
Yan Zheng2c47e6052009-06-27 21:07:35 -0400656#if 0
Chris Masond352ac62008-09-29 15:18:18 -0400657/*
Chris Masonb7ec40d2009-03-12 20:12:45 -0400658 * when dropping snapshots, we generate a ton of delayed refs, and it makes
659 * sense not to join the transaction while it is trying to flush the current
660 * queue of delayed refs out.
661 *
662 * This is used by the drop snapshot code only
663 */
664static noinline int wait_transaction_pre_flush(struct btrfs_fs_info *info)
665{
666 DEFINE_WAIT(wait);
667
668 mutex_lock(&info->trans_mutex);
669 while (info->running_transaction &&
670 info->running_transaction->delayed_refs.flushing) {
671 prepare_to_wait(&info->transaction_wait, &wait,
672 TASK_UNINTERRUPTIBLE);
673 mutex_unlock(&info->trans_mutex);
Chris Mason59bc5c72009-04-24 14:39:25 -0400674
Chris Masonb7ec40d2009-03-12 20:12:45 -0400675 schedule();
Chris Mason59bc5c72009-04-24 14:39:25 -0400676
Chris Masonb7ec40d2009-03-12 20:12:45 -0400677 mutex_lock(&info->trans_mutex);
678 finish_wait(&info->transaction_wait, &wait);
679 }
680 mutex_unlock(&info->trans_mutex);
681 return 0;
682}
683
684/*
Chris Masond352ac62008-09-29 15:18:18 -0400685 * Given a list of roots that need to be deleted, call btrfs_drop_snapshot on
686 * all of them
687 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400688int btrfs_drop_dead_root(struct btrfs_root *root)
Chris Mason0f7d52f2007-04-09 10:42:37 -0400689{
Chris Mason0f7d52f2007-04-09 10:42:37 -0400690 struct btrfs_trans_handle *trans;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400691 struct btrfs_root *tree_root = root->fs_info->tree_root;
Chris Masond3c2fdc2007-09-17 10:58:06 -0400692 unsigned long nr;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400693 int ret;
Chris Mason9f3a7422007-08-07 15:52:19 -0400694
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400695 while (1) {
696 /*
697 * we don't want to jump in and create a bunch of
698 * delayed refs if the transaction is starting to close
699 */
700 wait_transaction_pre_flush(tree_root->fs_info);
701 trans = btrfs_start_transaction(tree_root, 1);
Josef Bacik58176a92007-08-29 15:47:34 -0400702
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400703 /*
704 * we've joined a transaction, make sure it isn't
705 * closing right now
706 */
707 if (trans->transaction->delayed_refs.flushing) {
708 btrfs_end_transaction(trans, tree_root);
709 continue;
Josef Bacik58176a92007-08-29 15:47:34 -0400710 }
Chris Masona2135012008-06-25 16:01:30 -0400711
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400712 ret = btrfs_drop_snapshot(trans, root);
713 if (ret != -EAGAIN)
Chris Mason54aa1f42007-06-22 14:16:25 -0400714 break;
Chris Masona2135012008-06-25 16:01:30 -0400715
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400716 ret = btrfs_update_root(trans, tree_root,
717 &root->root_key,
718 &root->root_item);
719 if (ret)
720 break;
Yanbcc63ab2008-07-30 16:29:20 -0400721
Chris Masond3c2fdc2007-09-17 10:58:06 -0400722 nr = trans->blocks_used;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400723 ret = btrfs_end_transaction(trans, tree_root);
724 BUG_ON(ret);
Chris Mason5eda7b52007-06-22 14:16:25 -0400725
Chris Masond3c2fdc2007-09-17 10:58:06 -0400726 btrfs_btree_balance_dirty(tree_root, nr);
Chris Mason4dc11902007-10-15 16:18:14 -0400727 cond_resched();
Chris Mason0f7d52f2007-04-09 10:42:37 -0400728 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400729 BUG_ON(ret);
730
731 ret = btrfs_del_root(trans, tree_root, &root->root_key);
732 BUG_ON(ret);
733
734 nr = trans->blocks_used;
735 ret = btrfs_end_transaction(trans, tree_root);
736 BUG_ON(ret);
737
738 free_extent_buffer(root->node);
739 free_extent_buffer(root->commit_root);
740 kfree(root);
741
742 btrfs_btree_balance_dirty(tree_root, nr);
Chris Mason54aa1f42007-06-22 14:16:25 -0400743 return ret;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400744}
Yan Zheng2c47e6052009-06-27 21:07:35 -0400745#endif
Chris Mason0f7d52f2007-04-09 10:42:37 -0400746
Chris Masond352ac62008-09-29 15:18:18 -0400747/*
748 * new snapshots need to be created at a very specific time in the
749 * transaction commit. This does the actual creation
750 */
Chris Mason80b67942008-02-01 16:35:04 -0500751static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
Chris Mason3063d292008-01-08 15:46:30 -0500752 struct btrfs_fs_info *fs_info,
753 struct btrfs_pending_snapshot *pending)
754{
755 struct btrfs_key key;
Chris Mason80b67942008-02-01 16:35:04 -0500756 struct btrfs_root_item *new_root_item;
Chris Mason3063d292008-01-08 15:46:30 -0500757 struct btrfs_root *tree_root = fs_info->tree_root;
758 struct btrfs_root *root = pending->root;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000759 struct btrfs_root *parent_root;
760 struct inode *parent_inode;
Chris Mason3063d292008-01-08 15:46:30 -0500761 struct extent_buffer *tmp;
Chris Mason925baed2008-06-25 16:01:30 -0400762 struct extent_buffer *old;
Chris Mason3063d292008-01-08 15:46:30 -0500763 int ret;
764 u64 objectid;
Sage Weil6bdb72d2010-03-15 17:27:13 +0000765 int namelen;
766 u64 index = 0;
767
768 parent_inode = pending->dentry->d_parent->d_inode;
769 parent_root = BTRFS_I(parent_inode)->root;
Chris Mason3063d292008-01-08 15:46:30 -0500770
Chris Mason80b67942008-02-01 16:35:04 -0500771 new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
772 if (!new_root_item) {
773 ret = -ENOMEM;
774 goto fail;
775 }
Chris Mason3063d292008-01-08 15:46:30 -0500776 ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid);
777 if (ret)
778 goto fail;
779
Chris Mason3063d292008-01-08 15:46:30 -0500780 key.objectid = objectid;
Yan, Zheng1c4850e2009-09-21 15:55:59 -0400781 /* record when the snapshot was created in key.offset */
782 key.offset = trans->transid;
Chris Mason3063d292008-01-08 15:46:30 -0500783 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
784
Sage Weil6bdb72d2010-03-15 17:27:13 +0000785 memcpy(&pending->root_key, &key, sizeof(key));
786 pending->root_key.offset = (u64)-1;
787
788 record_root_in_trans(trans, parent_root);
789 /*
790 * insert the directory item
791 */
792 namelen = strlen(pending->name);
793 ret = btrfs_set_inode_index(parent_inode, &index);
794 BUG_ON(ret);
795 ret = btrfs_insert_dir_item(trans, parent_root,
796 pending->name, namelen,
797 parent_inode->i_ino,
798 &pending->root_key, BTRFS_FT_DIR, index);
799 BUG_ON(ret);
800
801 btrfs_i_size_write(parent_inode, parent_inode->i_size + namelen * 2);
802 ret = btrfs_update_inode(trans, parent_root, parent_inode);
803 BUG_ON(ret);
804
805 record_root_in_trans(trans, root);
806 btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
807 memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
808
Chris Mason925baed2008-06-25 16:01:30 -0400809 old = btrfs_lock_root_node(root);
Chris Mason9fa8cfe2009-03-13 10:24:59 -0400810 btrfs_cow_block(trans, root, old, NULL, 0, &old);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400811 btrfs_set_lock_blocking(old);
Chris Mason3063d292008-01-08 15:46:30 -0500812
Chris Mason925baed2008-06-25 16:01:30 -0400813 btrfs_copy_root(trans, root, old, &tmp, objectid);
814 btrfs_tree_unlock(old);
815 free_extent_buffer(old);
Chris Mason3063d292008-01-08 15:46:30 -0500816
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400817 btrfs_set_root_node(new_root_item, tmp);
Chris Mason3063d292008-01-08 15:46:30 -0500818 ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
Chris Mason80b67942008-02-01 16:35:04 -0500819 new_root_item);
Sage Weil6bdb72d2010-03-15 17:27:13 +0000820 BUG_ON(ret);
Chris Mason925baed2008-06-25 16:01:30 -0400821 btrfs_tree_unlock(tmp);
Chris Mason3063d292008-01-08 15:46:30 -0500822 free_extent_buffer(tmp);
Yan Zheng52c26172009-01-05 15:43:43 -0500823
Chris Mason0660b5a2008-11-17 20:37:39 -0500824 ret = btrfs_add_root_ref(trans, parent_root->fs_info->tree_root,
825 pending->root_key.objectid,
Chris Mason0660b5a2008-11-17 20:37:39 -0500826 parent_root->root_key.objectid,
827 parent_inode->i_ino, index, pending->name,
828 namelen);
Chris Mason0660b5a2008-11-17 20:37:39 -0500829 BUG_ON(ret);
830
Chris Mason3063d292008-01-08 15:46:30 -0500831fail:
Sage Weil6bdb72d2010-03-15 17:27:13 +0000832 kfree(new_root_item);
Chris Mason3063d292008-01-08 15:46:30 -0500833 return ret;
834}
835
Chris Masond352ac62008-09-29 15:18:18 -0400836/*
837 * create all the snapshots we've scheduled for creation
838 */
Chris Mason80b67942008-02-01 16:35:04 -0500839static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
840 struct btrfs_fs_info *fs_info)
Chris Mason3063d292008-01-08 15:46:30 -0500841{
842 struct btrfs_pending_snapshot *pending;
843 struct list_head *head = &trans->transaction->pending_snapshots;
Chris Mason3de45862008-11-17 21:02:50 -0500844 int ret;
845
Qinghuang Fengc6e30872009-01-21 10:59:08 -0500846 list_for_each_entry(pending, head, list) {
Chris Mason3de45862008-11-17 21:02:50 -0500847 ret = create_pending_snapshot(trans, fs_info, pending);
848 BUG_ON(ret);
849 }
850 return 0;
851}
852
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400853static void update_super_roots(struct btrfs_root *root)
854{
855 struct btrfs_root_item *root_item;
856 struct btrfs_super_block *super;
857
858 super = &root->fs_info->super_copy;
859
860 root_item = &root->fs_info->chunk_root->root_item;
861 super->chunk_root = root_item->bytenr;
862 super->chunk_root_generation = root_item->generation;
863 super->chunk_root_level = root_item->level;
864
865 root_item = &root->fs_info->tree_root->root_item;
866 super->root = root_item->bytenr;
867 super->generation = root_item->generation;
868 super->root_level = root_item->level;
869}
870
Chris Masonf36f3042009-07-30 10:04:48 -0400871int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
872{
873 int ret = 0;
874 spin_lock(&info->new_trans_lock);
875 if (info->running_transaction)
876 ret = info->running_transaction->in_commit;
877 spin_unlock(&info->new_trans_lock);
878 return ret;
879}
880
Chris Mason79154b12007-03-22 15:59:16 -0400881int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
882 struct btrfs_root *root)
883{
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400884 unsigned long joined = 0;
885 unsigned long timeout = 1;
Chris Mason79154b12007-03-22 15:59:16 -0400886 struct btrfs_transaction *cur_trans;
Chris Mason8fd17792007-04-19 21:01:03 -0400887 struct btrfs_transaction *prev_trans = NULL;
Chris Mason79154b12007-03-22 15:59:16 -0400888 DEFINE_WAIT(wait);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400889 int ret;
Chris Mason89573b92009-03-12 20:12:45 -0400890 int should_grow = 0;
891 unsigned long now = get_seconds();
Sage Weildccae992009-04-02 16:59:01 -0400892 int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
Chris Mason79154b12007-03-22 15:59:16 -0400893
Chris Mason5a3f23d2009-03-31 13:27:11 -0400894 btrfs_run_ordered_operations(root, 0);
895
Chris Mason56bec292009-03-13 10:10:06 -0400896 /* make a pass through all the delayed refs we have so far
897 * any runnings procs may add more while we are here
898 */
899 ret = btrfs_run_delayed_refs(trans, root, 0);
900 BUG_ON(ret);
901
Chris Masonb7ec40d2009-03-12 20:12:45 -0400902 cur_trans = trans->transaction;
Chris Mason56bec292009-03-13 10:10:06 -0400903 /*
904 * set the flushing flag so procs in this transaction have to
905 * start sending their work down.
906 */
Chris Masonb7ec40d2009-03-12 20:12:45 -0400907 cur_trans->delayed_refs.flushing = 1;
Chris Mason56bec292009-03-13 10:10:06 -0400908
Chris Masonc3e69d52009-03-13 10:17:05 -0400909 ret = btrfs_run_delayed_refs(trans, root, 0);
Chris Mason56bec292009-03-13 10:10:06 -0400910 BUG_ON(ret);
911
Chris Mason79154b12007-03-22 15:59:16 -0400912 mutex_lock(&root->fs_info->trans_mutex);
Chris Masonb7ec40d2009-03-12 20:12:45 -0400913 if (cur_trans->in_commit) {
914 cur_trans->use_count++;
Chris Masonccd467d2007-06-28 15:57:36 -0400915 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400916 btrfs_end_transaction(trans, root);
Chris Masonccd467d2007-06-28 15:57:36 -0400917
Chris Mason79154b12007-03-22 15:59:16 -0400918 ret = wait_for_commit(root, cur_trans);
919 BUG_ON(ret);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400920
921 mutex_lock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400922 put_transaction(cur_trans);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400923 mutex_unlock(&root->fs_info->trans_mutex);
924
Chris Mason79154b12007-03-22 15:59:16 -0400925 return 0;
926 }
Chris Mason4313b392008-01-03 09:08:48 -0500927
Chris Mason2c90e5d2007-04-02 10:50:19 -0400928 trans->transaction->in_commit = 1;
Chris Masonf9295742008-07-17 12:54:14 -0400929 trans->transaction->blocked = 1;
Chris Masonccd467d2007-06-28 15:57:36 -0400930 if (cur_trans->list.prev != &root->fs_info->trans_list) {
931 prev_trans = list_entry(cur_trans->list.prev,
932 struct btrfs_transaction, list);
933 if (!prev_trans->commit_done) {
934 prev_trans->use_count++;
Chris Masonccd467d2007-06-28 15:57:36 -0400935 mutex_unlock(&root->fs_info->trans_mutex);
936
937 wait_for_commit(root, prev_trans);
Chris Masonccd467d2007-06-28 15:57:36 -0400938
Chris Masonccd467d2007-06-28 15:57:36 -0400939 mutex_lock(&root->fs_info->trans_mutex);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400940 put_transaction(prev_trans);
Chris Masonccd467d2007-06-28 15:57:36 -0400941 }
942 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400943
Chris Mason89573b92009-03-12 20:12:45 -0400944 if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
945 should_grow = 1;
946
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400947 do {
Yan Zheng7ea394f2008-08-05 13:05:02 -0400948 int snap_pending = 0;
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400949 joined = cur_trans->num_joined;
Yan Zheng7ea394f2008-08-05 13:05:02 -0400950 if (!list_empty(&trans->transaction->pending_snapshots))
951 snap_pending = 1;
952
Chris Mason2c90e5d2007-04-02 10:50:19 -0400953 WARN_ON(cur_trans != trans->transaction);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400954 prepare_to_wait(&cur_trans->writer_wait, &wait,
Chris Mason79154b12007-03-22 15:59:16 -0400955 TASK_UNINTERRUPTIBLE);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400956
957 if (cur_trans->num_writers > 1)
958 timeout = MAX_SCHEDULE_TIMEOUT;
Chris Mason89573b92009-03-12 20:12:45 -0400959 else if (should_grow)
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400960 timeout = 1;
961
Chris Mason79154b12007-03-22 15:59:16 -0400962 mutex_unlock(&root->fs_info->trans_mutex);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400963
Sage Weil0bdb1db2010-02-19 14:13:50 -0800964 if (flush_on_commit || snap_pending) {
Yan, Zheng24bbcf02009-11-12 09:36:34 +0000965 btrfs_start_delalloc_inodes(root, 1);
966 ret = btrfs_wait_ordered_extents(root, 0, 1);
Sage Weilebecd3d2009-07-24 13:17:44 -0400967 BUG_ON(ret);
Yan Zheng7ea394f2008-08-05 13:05:02 -0400968 }
969
Chris Mason5a3f23d2009-03-31 13:27:11 -0400970 /*
971 * rename don't use btrfs_join_transaction, so, once we
972 * set the transaction to blocked above, we aren't going
973 * to get any new ordered operations. We can safely run
974 * it here and no for sure that nothing new will be added
975 * to the list
976 */
977 btrfs_run_ordered_operations(root, 1);
978
Chris Mason89573b92009-03-12 20:12:45 -0400979 smp_mb();
980 if (cur_trans->num_writers > 1 || should_grow)
981 schedule_timeout(timeout);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400982
Chris Mason79154b12007-03-22 15:59:16 -0400983 mutex_lock(&root->fs_info->trans_mutex);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400984 finish_wait(&cur_trans->writer_wait, &wait);
985 } while (cur_trans->num_writers > 1 ||
Chris Mason89573b92009-03-12 20:12:45 -0400986 (should_grow && cur_trans->num_joined != joined));
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400987
Chris Mason3063d292008-01-08 15:46:30 -0500988 ret = create_pending_snapshots(trans, root->fs_info);
989 BUG_ON(ret);
990
Chris Mason56bec292009-03-13 10:10:06 -0400991 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
992 BUG_ON(ret);
993
Chris Mason2c90e5d2007-04-02 10:50:19 -0400994 WARN_ON(cur_trans != trans->transaction);
Chris Masondc17ff82008-01-08 15:46:30 -0500995
Chris Masone02119d2008-09-05 16:13:11 -0400996 /* btrfs_commit_tree_roots is responsible for getting the
997 * various roots consistent with each other. Every pointer
998 * in the tree of tree roots has to point to the most up to date
999 * root for every subvolume and other tree. So, we have to keep
1000 * the tree logging code from jumping in and changing any
1001 * of the trees.
1002 *
1003 * At this point in the commit, there can't be any tree-log
1004 * writers, but a little lower down we drop the trans mutex
1005 * and let new people in. By holding the tree_log_mutex
1006 * from now until after the super is written, we avoid races
1007 * with the tree-log code.
1008 */
1009 mutex_lock(&root->fs_info->tree_log_mutex);
Zheng Yan1a40e232008-09-26 10:09:34 -04001010
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001011 ret = commit_fs_roots(trans, root);
Chris Mason54aa1f42007-06-22 14:16:25 -04001012 BUG_ON(ret);
1013
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001014 /* commit_fs_roots gets rid of all the tree log roots, it is now
Chris Masone02119d2008-09-05 16:13:11 -04001015 * safe to free the root of tree log roots
1016 */
1017 btrfs_free_log_root_tree(trans, root->fs_info);
1018
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001019 ret = commit_cowonly_roots(trans, root);
Chris Mason79154b12007-03-22 15:59:16 -04001020 BUG_ON(ret);
Chris Mason54aa1f42007-06-22 14:16:25 -04001021
Yan Zheng11833d62009-09-11 16:11:19 -04001022 btrfs_prepare_extent_commit(trans, root);
1023
Chris Mason78fae272007-03-25 11:35:08 -04001024 cur_trans = root->fs_info->running_transaction;
Chris Masoncee36a02008-01-15 08:40:48 -05001025 spin_lock(&root->fs_info->new_trans_lock);
Chris Mason78fae272007-03-25 11:35:08 -04001026 root->fs_info->running_transaction = NULL;
Chris Masoncee36a02008-01-15 08:40:48 -05001027 spin_unlock(&root->fs_info->new_trans_lock);
Chris Mason5f39d392007-10-15 16:14:19 -04001028
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001029 btrfs_set_root_node(&root->fs_info->tree_root->root_item,
1030 root->fs_info->tree_root->node);
Josef Bacik817d52f2009-07-13 21:29:25 -04001031 switch_commit_root(root->fs_info->tree_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001032
1033 btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
1034 root->fs_info->chunk_root->node);
Josef Bacik817d52f2009-07-13 21:29:25 -04001035 switch_commit_root(root->fs_info->chunk_root);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001036
1037 update_super_roots(root);
Chris Masone02119d2008-09-05 16:13:11 -04001038
1039 if (!root->fs_info->log_root_recovering) {
1040 btrfs_set_super_log_root(&root->fs_info->super_copy, 0);
1041 btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0);
1042 }
1043
Chris Masona061fc82008-05-07 11:43:44 -04001044 memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
1045 sizeof(root->fs_info->super_copy));
Chris Masonccd467d2007-06-28 15:57:36 -04001046
Chris Masonf9295742008-07-17 12:54:14 -04001047 trans->transaction->blocked = 0;
Chris Masonb7ec40d2009-03-12 20:12:45 -04001048
Chris Masonf9295742008-07-17 12:54:14 -04001049 wake_up(&root->fs_info->transaction_wait);
Chris Masone6dcd2d2008-07-17 12:53:50 -04001050
Chris Mason78fae272007-03-25 11:35:08 -04001051 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -04001052 ret = btrfs_write_and_wait_transaction(trans, root);
1053 BUG_ON(ret);
Yan Zhenga512bbf2008-12-08 16:46:26 -05001054 write_ctree_super(trans, root, 0);
Chris Mason4313b392008-01-03 09:08:48 -05001055
Chris Masone02119d2008-09-05 16:13:11 -04001056 /*
1057 * the super is written, we can safely allow the tree-loggers
1058 * to go about their business
1059 */
1060 mutex_unlock(&root->fs_info->tree_log_mutex);
1061
Yan Zheng11833d62009-09-11 16:11:19 -04001062 btrfs_finish_extent_commit(trans, root);
Chris Mason4313b392008-01-03 09:08:48 -05001063
Zheng Yan1a40e232008-09-26 10:09:34 -04001064 mutex_lock(&root->fs_info->trans_mutex);
1065
Chris Mason2c90e5d2007-04-02 10:50:19 -04001066 cur_trans->commit_done = 1;
Chris Masonb7ec40d2009-03-12 20:12:45 -04001067
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001068 root->fs_info->last_trans_committed = cur_trans->transid;
Josef Bacik817d52f2009-07-13 21:29:25 -04001069
Chris Mason2c90e5d2007-04-02 10:50:19 -04001070 wake_up(&cur_trans->commit_wait);
Chris Mason3de45862008-11-17 21:02:50 -05001071
Chris Mason79154b12007-03-22 15:59:16 -04001072 put_transaction(cur_trans);
Chris Mason78fae272007-03-25 11:35:08 -04001073 put_transaction(cur_trans);
Josef Bacik58176a92007-08-29 15:47:34 -04001074
Chris Mason78fae272007-03-25 11:35:08 -04001075 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason3de45862008-11-17 21:02:50 -05001076
Josef Bacik9ed74f22009-09-11 16:12:44 -04001077 if (current->journal_info == trans)
1078 current->journal_info = NULL;
1079
Chris Mason2c90e5d2007-04-02 10:50:19 -04001080 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Yan, Zheng24bbcf02009-11-12 09:36:34 +00001081
1082 if (current != root->fs_info->transaction_kthread)
1083 btrfs_run_delayed_iputs(root);
1084
Chris Mason79154b12007-03-22 15:59:16 -04001085 return ret;
1086}
1087
Chris Masond352ac62008-09-29 15:18:18 -04001088/*
1089 * interface function to delete all the snapshots we have scheduled for deletion
1090 */
Chris Masone9d0b132007-08-10 14:06:19 -04001091int btrfs_clean_old_snapshots(struct btrfs_root *root)
1092{
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001093 LIST_HEAD(list);
1094 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Masone9d0b132007-08-10 14:06:19 -04001095
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001096 mutex_lock(&fs_info->trans_mutex);
1097 list_splice_init(&fs_info->dead_roots, &list);
1098 mutex_unlock(&fs_info->trans_mutex);
1099
1100 while (!list_empty(&list)) {
1101 root = list_entry(list.next, struct btrfs_root, root_list);
Yan, Zheng76dda932009-09-21 16:00:26 -04001102 list_del(&root->root_list);
1103
1104 if (btrfs_header_backref_rev(root->node) <
1105 BTRFS_MIXED_BACKREF_REV)
1106 btrfs_drop_snapshot(root, 0);
1107 else
1108 btrfs_drop_snapshot(root, 1);
Chris Masone9d0b132007-08-10 14:06:19 -04001109 }
1110 return 0;
1111}