blob: 372b61f5733fea2a9a562af8732e5ee00dc705f8 [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>
Chris Mason34088782007-06-12 11:36:58 -040020#include <linux/sched.h>
Chris Masond3c2fdcf2007-09-17 10:58:06 -040021#include <linux/writeback.h>
Chris Mason5f39d392007-10-15 16:14:19 -040022#include <linux/pagemap.h>
Chris Mason79154b12007-03-22 15:59:16 -040023#include "ctree.h"
24#include "disk-io.h"
25#include "transaction.h"
26
Chris Mason78fae272007-03-25 11:35:08 -040027static int total_trans = 0;
Chris Mason2c90e5d2007-04-02 10:50:19 -040028extern struct kmem_cache *btrfs_trans_handle_cachep;
29extern struct kmem_cache *btrfs_transaction_cachep;
30
Chris Mason08607c12007-06-08 15:33:54 -040031static struct workqueue_struct *trans_wq;
32
Chris Mason0f7d52f2007-04-09 10:42:37 -040033#define BTRFS_ROOT_TRANS_TAG 0
Chris Mason6702ed42007-08-07 16:15:09 -040034#define BTRFS_ROOT_DEFRAG_TAG 1
Chris Mason0f7d52f2007-04-09 10:42:37 -040035
Chris Mason79154b12007-03-22 15:59:16 -040036static void put_transaction(struct btrfs_transaction *transaction)
37{
Chris Mason2c90e5d2007-04-02 10:50:19 -040038 WARN_ON(transaction->use_count == 0);
Chris Mason79154b12007-03-22 15:59:16 -040039 transaction->use_count--;
Chris Mason78fae272007-03-25 11:35:08 -040040 if (transaction->use_count == 0) {
41 WARN_ON(total_trans == 0);
42 total_trans--;
Chris Mason8fd17792007-04-19 21:01:03 -040043 list_del_init(&transaction->list);
Chris Mason2c90e5d2007-04-02 10:50:19 -040044 memset(transaction, 0, sizeof(*transaction));
45 kmem_cache_free(btrfs_transaction_cachep, transaction);
Chris Mason78fae272007-03-25 11:35:08 -040046 }
Chris Mason79154b12007-03-22 15:59:16 -040047}
48
49static int join_transaction(struct btrfs_root *root)
50{
51 struct btrfs_transaction *cur_trans;
52 cur_trans = root->fs_info->running_transaction;
53 if (!cur_trans) {
Chris Mason2c90e5d2007-04-02 10:50:19 -040054 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep,
55 GFP_NOFS);
Chris Mason78fae272007-03-25 11:35:08 -040056 total_trans++;
Chris Mason79154b12007-03-22 15:59:16 -040057 BUG_ON(!cur_trans);
Chris Mason0f7d52f2007-04-09 10:42:37 -040058 root->fs_info->generation++;
Chris Mason79154b12007-03-22 15:59:16 -040059 root->fs_info->running_transaction = cur_trans;
Josef Bacik15ee9bc2007-08-10 16:22:09 -040060 cur_trans->num_writers = 1;
61 cur_trans->num_joined = 0;
Chris Mason0f7d52f2007-04-09 10:42:37 -040062 cur_trans->transid = root->fs_info->generation;
Chris Mason79154b12007-03-22 15:59:16 -040063 init_waitqueue_head(&cur_trans->writer_wait);
64 init_waitqueue_head(&cur_trans->commit_wait);
65 cur_trans->in_commit = 0;
Chris Masond5719762007-03-23 10:01:08 -040066 cur_trans->use_count = 1;
Chris Mason79154b12007-03-22 15:59:16 -040067 cur_trans->commit_done = 0;
Chris Mason08607c12007-06-08 15:33:54 -040068 cur_trans->start_time = get_seconds();
Chris Mason8fd17792007-04-19 21:01:03 -040069 list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
Chris Mason5f39d392007-10-15 16:14:19 -040070 extent_map_tree_init(&cur_trans->dirty_pages,
71 root->fs_info->btree_inode->i_mapping,
72 GFP_NOFS);
Josef Bacik15ee9bc2007-08-10 16:22:09 -040073 } else {
74 cur_trans->num_writers++;
75 cur_trans->num_joined++;
Chris Mason79154b12007-03-22 15:59:16 -040076 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -040077
Chris Mason79154b12007-03-22 15:59:16 -040078 return 0;
79}
80
Chris Mason6702ed42007-08-07 16:15:09 -040081static int record_root_in_trans(struct btrfs_root *root)
82{
83 u64 running_trans_id = root->fs_info->running_transaction->transid;
84 if (root->ref_cows && root->last_trans < running_trans_id) {
85 WARN_ON(root == root->fs_info->extent_root);
86 if (root->root_item.refs != 0) {
87 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
88 (unsigned long)root->root_key.objectid,
89 BTRFS_ROOT_TRANS_TAG);
90 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
91 (unsigned long)root->root_key.objectid,
92 BTRFS_ROOT_DEFRAG_TAG);
93 root->commit_root = root->node;
Chris Mason5f39d392007-10-15 16:14:19 -040094 extent_buffer_get(root->node);
Chris Mason6702ed42007-08-07 16:15:09 -040095 } else {
96 WARN_ON(1);
97 }
98 root->last_trans = running_trans_id;
99 }
100 return 0;
101}
102
Chris Mason79154b12007-03-22 15:59:16 -0400103struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
104 int num_blocks)
105{
Chris Mason2c90e5d2007-04-02 10:50:19 -0400106 struct btrfs_trans_handle *h =
107 kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
Chris Mason79154b12007-03-22 15:59:16 -0400108 int ret;
109
110 mutex_lock(&root->fs_info->trans_mutex);
111 ret = join_transaction(root);
112 BUG_ON(ret);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400113
Chris Mason6702ed42007-08-07 16:15:09 -0400114 record_root_in_trans(root);
115 h->transid = root->fs_info->running_transaction->transid;
Chris Mason79154b12007-03-22 15:59:16 -0400116 h->transaction = root->fs_info->running_transaction;
117 h->blocks_reserved = num_blocks;
118 h->blocks_used = 0;
Chris Mason31f3c992007-04-30 15:25:45 -0400119 h->block_group = NULL;
Chris Mason26b80032007-08-08 20:17:12 -0400120 h->alloc_exclude_nr = 0;
121 h->alloc_exclude_start = 0;
Chris Mason79154b12007-03-22 15:59:16 -0400122 root->fs_info->running_transaction->use_count++;
123 mutex_unlock(&root->fs_info->trans_mutex);
124 return h;
125}
126
127int btrfs_end_transaction(struct btrfs_trans_handle *trans,
128 struct btrfs_root *root)
129{
130 struct btrfs_transaction *cur_trans;
Chris Masond6e4a422007-04-06 15:37:36 -0400131
Chris Mason79154b12007-03-22 15:59:16 -0400132 mutex_lock(&root->fs_info->trans_mutex);
133 cur_trans = root->fs_info->running_transaction;
Chris Masonccd467d2007-06-28 15:57:36 -0400134 WARN_ON(cur_trans != trans->transaction);
Chris Masond5719762007-03-23 10:01:08 -0400135 WARN_ON(cur_trans->num_writers < 1);
Chris Masonccd467d2007-06-28 15:57:36 -0400136 cur_trans->num_writers--;
Chris Mason79154b12007-03-22 15:59:16 -0400137 if (waitqueue_active(&cur_trans->writer_wait))
138 wake_up(&cur_trans->writer_wait);
Chris Mason79154b12007-03-22 15:59:16 -0400139 put_transaction(cur_trans);
140 mutex_unlock(&root->fs_info->trans_mutex);
Chris Masond6025572007-03-30 14:27:56 -0400141 memset(trans, 0, sizeof(*trans));
Chris Mason2c90e5d2007-04-02 10:50:19 -0400142 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Chris Mason79154b12007-03-22 15:59:16 -0400143 return 0;
144}
145
146
147int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
148 struct btrfs_root *root)
149{
Chris Mason7c4452b2007-04-28 09:29:35 -0400150 int ret;
Chris Mason7c4452b2007-04-28 09:29:35 -0400151 int err;
152 int werr = 0;
Chris Mason5f39d392007-10-15 16:14:19 -0400153 struct extent_map_tree *dirty_pages;
Chris Mason7c4452b2007-04-28 09:29:35 -0400154 struct page *page;
Chris Mason7c4452b2007-04-28 09:29:35 -0400155 struct inode *btree_inode = root->fs_info->btree_inode;
Chris Mason5f39d392007-10-15 16:14:19 -0400156 u64 start;
157 u64 end;
158 unsigned long index;
Chris Mason7c4452b2007-04-28 09:29:35 -0400159
160 if (!trans || !trans->transaction) {
161 return filemap_write_and_wait(btree_inode->i_mapping);
162 }
163 dirty_pages = &trans->transaction->dirty_pages;
164 while(1) {
Chris Mason5f39d392007-10-15 16:14:19 -0400165 ret = find_first_extent_bit(dirty_pages, 0, &start, &end,
166 EXTENT_DIRTY);
167 if (ret)
Chris Mason7c4452b2007-04-28 09:29:35 -0400168 break;
Chris Mason5f39d392007-10-15 16:14:19 -0400169 clear_extent_dirty(dirty_pages, start, end, GFP_NOFS);
170 while(start <= end) {
171 index = start >> PAGE_CACHE_SHIFT;
172 start = (index + 1) << PAGE_CACHE_SHIFT;
173 page = find_lock_page(btree_inode->i_mapping, index);
Chris Mason7c4452b2007-04-28 09:29:35 -0400174 if (!page)
175 continue;
Chris Mason6702ed42007-08-07 16:15:09 -0400176 if (PageWriteback(page)) {
177 if (PageDirty(page))
178 wait_on_page_writeback(page);
179 else {
180 unlock_page(page);
181 page_cache_release(page);
182 continue;
183 }
184 }
Chris Mason7c4452b2007-04-28 09:29:35 -0400185 err = write_one_page(page, 0);
186 if (err)
187 werr = err;
188 page_cache_release(page);
189 }
190 }
191 err = filemap_fdatawait(btree_inode->i_mapping);
192 if (err)
193 werr = err;
194 return werr;
Chris Mason79154b12007-03-22 15:59:16 -0400195}
196
197int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans,
198 struct btrfs_root *root)
199{
200 int ret;
201 u64 old_extent_block;
202 struct btrfs_fs_info *fs_info = root->fs_info;
203 struct btrfs_root *tree_root = fs_info->tree_root;
204 struct btrfs_root *extent_root = fs_info->extent_root;
Chris Mason79154b12007-03-22 15:59:16 -0400205
Chris Mason9078a3e2007-04-26 16:46:15 -0400206 btrfs_write_dirty_block_groups(trans, extent_root);
Chris Mason79154b12007-03-22 15:59:16 -0400207 while(1) {
208 old_extent_block = btrfs_root_blocknr(&extent_root->root_item);
Chris Mason5f39d392007-10-15 16:14:19 -0400209 if (old_extent_block ==
210 extent_buffer_blocknr(extent_root->node))
Chris Mason79154b12007-03-22 15:59:16 -0400211 break;
212 btrfs_set_root_blocknr(&extent_root->root_item,
Chris Mason5f39d392007-10-15 16:14:19 -0400213 extent_buffer_blocknr(extent_root->node));
Chris Mason79154b12007-03-22 15:59:16 -0400214 ret = btrfs_update_root(trans, tree_root,
215 &extent_root->root_key,
216 &extent_root->root_item);
217 BUG_ON(ret);
Chris Mason9078a3e2007-04-26 16:46:15 -0400218 btrfs_write_dirty_block_groups(trans, extent_root);
Chris Mason79154b12007-03-22 15:59:16 -0400219 }
220 return 0;
221}
222
223static int wait_for_commit(struct btrfs_root *root,
224 struct btrfs_transaction *commit)
225{
226 DEFINE_WAIT(wait);
Chris Masonccd467d2007-06-28 15:57:36 -0400227 mutex_lock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400228 while(!commit->commit_done) {
229 prepare_to_wait(&commit->commit_wait, &wait,
230 TASK_UNINTERRUPTIBLE);
231 if (commit->commit_done)
232 break;
233 mutex_unlock(&root->fs_info->trans_mutex);
234 schedule();
235 mutex_lock(&root->fs_info->trans_mutex);
236 }
Chris Masonccd467d2007-06-28 15:57:36 -0400237 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400238 finish_wait(&commit->commit_wait, &wait);
239 return 0;
240}
241
Chris Mason0f7d52f2007-04-09 10:42:37 -0400242struct dirty_root {
243 struct list_head list;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400244 struct btrfs_root *root;
Josef Bacik58176a92007-08-29 15:47:34 -0400245 struct btrfs_root *latest_root;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400246};
247
Chris Mason5ce14bb2007-09-11 11:15:39 -0400248int btrfs_add_dead_root(struct btrfs_root *root,
249 struct btrfs_root *latest,
250 struct list_head *dead_list)
Chris Mason5eda7b52007-06-22 14:16:25 -0400251{
252 struct dirty_root *dirty;
253
254 dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
255 if (!dirty)
256 return -ENOMEM;
Chris Mason5eda7b52007-06-22 14:16:25 -0400257 dirty->root = root;
Chris Mason5ce14bb2007-09-11 11:15:39 -0400258 dirty->latest_root = latest;
Chris Mason5eda7b52007-06-22 14:16:25 -0400259 list_add(&dirty->list, dead_list);
260 return 0;
261}
262
Chris Mason35b7e472007-05-02 15:53:43 -0400263static int add_dirty_roots(struct btrfs_trans_handle *trans,
264 struct radix_tree_root *radix,
265 struct list_head *list)
Chris Mason0f7d52f2007-04-09 10:42:37 -0400266{
267 struct dirty_root *dirty;
268 struct btrfs_root *gang[8];
269 struct btrfs_root *root;
270 int i;
271 int ret;
Chris Mason54aa1f42007-06-22 14:16:25 -0400272 int err = 0;
Chris Mason5eda7b52007-06-22 14:16:25 -0400273 u32 refs;
Chris Mason54aa1f42007-06-22 14:16:25 -0400274
Chris Mason0f7d52f2007-04-09 10:42:37 -0400275 while(1) {
276 ret = radix_tree_gang_lookup_tag(radix, (void **)gang, 0,
277 ARRAY_SIZE(gang),
278 BTRFS_ROOT_TRANS_TAG);
279 if (ret == 0)
280 break;
281 for (i = 0; i < ret; i++) {
282 root = gang[i];
Chris Mason2619ba12007-04-10 16:58:11 -0400283 radix_tree_tag_clear(radix,
284 (unsigned long)root->root_key.objectid,
285 BTRFS_ROOT_TRANS_TAG);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400286 if (root->commit_root == root->node) {
Chris Mason5f39d392007-10-15 16:14:19 -0400287 WARN_ON(extent_buffer_blocknr(root->node) !=
Chris Mason0f7d52f2007-04-09 10:42:37 -0400288 btrfs_root_blocknr(&root->root_item));
Chris Mason5f39d392007-10-15 16:14:19 -0400289 free_extent_buffer(root->commit_root);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400290 root->commit_root = NULL;
Josef Bacik58176a92007-08-29 15:47:34 -0400291
292 /* make sure to update the root on disk
293 * so we get any updates to the block used
294 * counts
295 */
296 err = btrfs_update_root(trans,
297 root->fs_info->tree_root,
298 &root->root_key,
299 &root->root_item);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400300 continue;
301 }
302 dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
303 BUG_ON(!dirty);
Chris Mason9f3a7422007-08-07 15:52:19 -0400304 dirty->root = kmalloc(sizeof(*dirty->root), GFP_NOFS);
305 BUG_ON(!dirty->root);
306
307 memset(&root->root_item.drop_progress, 0,
308 sizeof(struct btrfs_disk_key));
309 root->root_item.drop_level = 0;
310
311 memcpy(dirty->root, root, sizeof(*root));
312 dirty->root->node = root->commit_root;
Josef Bacik58176a92007-08-29 15:47:34 -0400313 dirty->latest_root = root;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400314 root->commit_root = NULL;
Chris Mason5eda7b52007-06-22 14:16:25 -0400315
Chris Mason0f7d52f2007-04-09 10:42:37 -0400316 root->root_key.offset = root->fs_info->generation;
317 btrfs_set_root_blocknr(&root->root_item,
Chris Mason5f39d392007-10-15 16:14:19 -0400318 extent_buffer_blocknr(root->node));
Chris Mason0f7d52f2007-04-09 10:42:37 -0400319 err = btrfs_insert_root(trans, root->fs_info->tree_root,
320 &root->root_key,
321 &root->root_item);
Chris Mason54aa1f42007-06-22 14:16:25 -0400322 if (err)
323 break;
Chris Mason9f3a7422007-08-07 15:52:19 -0400324
325 refs = btrfs_root_refs(&dirty->root->root_item);
326 btrfs_set_root_refs(&dirty->root->root_item, refs - 1);
Chris Mason5eda7b52007-06-22 14:16:25 -0400327 err = btrfs_update_root(trans, root->fs_info->tree_root,
Chris Mason9f3a7422007-08-07 15:52:19 -0400328 &dirty->root->root_key,
329 &dirty->root->root_item);
Chris Mason5eda7b52007-06-22 14:16:25 -0400330
331 BUG_ON(err);
Chris Mason9f3a7422007-08-07 15:52:19 -0400332 if (refs == 1) {
Chris Mason5eda7b52007-06-22 14:16:25 -0400333 list_add(&dirty->list, list);
Chris Mason9f3a7422007-08-07 15:52:19 -0400334 } else {
335 WARN_ON(1);
336 kfree(dirty->root);
Chris Mason5eda7b52007-06-22 14:16:25 -0400337 kfree(dirty);
Chris Mason9f3a7422007-08-07 15:52:19 -0400338 }
Chris Mason0f7d52f2007-04-09 10:42:37 -0400339 }
340 }
Chris Mason54aa1f42007-06-22 14:16:25 -0400341 return err;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400342}
343
Chris Masone9d0b132007-08-10 14:06:19 -0400344int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
345{
346 struct btrfs_fs_info *info = root->fs_info;
347 int ret;
348 struct btrfs_trans_handle *trans;
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400349 unsigned long nr;
Chris Masone9d0b132007-08-10 14:06:19 -0400350
351 if (root->defrag_running)
352 return 0;
353
354 trans = btrfs_start_transaction(root, 1);
Chris Masonf510cfe2007-10-15 16:14:48 -0400355 while (0) {
Chris Masone9d0b132007-08-10 14:06:19 -0400356 root->defrag_running = 1;
357 ret = btrfs_defrag_leaves(trans, root, cacheonly);
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400358 nr = trans->blocks_used;
Chris Masone9d0b132007-08-10 14:06:19 -0400359 btrfs_end_transaction(trans, root);
360 mutex_unlock(&info->fs_mutex);
361
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400362 btrfs_btree_balance_dirty(info->tree_root, nr);
Chris Masone9d0b132007-08-10 14:06:19 -0400363 cond_resched();
364
365 mutex_lock(&info->fs_mutex);
366 trans = btrfs_start_transaction(root, 1);
367 if (ret != -EAGAIN)
368 break;
369 }
370 root->defrag_running = 0;
371 radix_tree_tag_clear(&info->fs_roots_radix,
372 (unsigned long)root->root_key.objectid,
373 BTRFS_ROOT_DEFRAG_TAG);
374 btrfs_end_transaction(trans, root);
375 return 0;
376}
377
Chris Mason6702ed42007-08-07 16:15:09 -0400378int btrfs_defrag_dirty_roots(struct btrfs_fs_info *info)
379{
380 struct btrfs_root *gang[1];
381 struct btrfs_root *root;
Chris Mason6702ed42007-08-07 16:15:09 -0400382 int i;
383 int ret;
384 int err = 0;
385 u64 last = 0;
386
Chris Mason6702ed42007-08-07 16:15:09 -0400387 while(1) {
388 ret = radix_tree_gang_lookup_tag(&info->fs_roots_radix,
389 (void **)gang, last,
390 ARRAY_SIZE(gang),
391 BTRFS_ROOT_DEFRAG_TAG);
392 if (ret == 0)
393 break;
394 for (i = 0; i < ret; i++) {
395 root = gang[i];
396 last = root->root_key.objectid + 1;
Chris Masonf510cfe2007-10-15 16:14:48 -0400397 btrfs_defrag_root(root, 1);
Chris Mason6702ed42007-08-07 16:15:09 -0400398 }
399 }
Chris Mason5f39d392007-10-15 16:14:19 -0400400 // btrfs_defrag_root(info->extent_root, 1);
Chris Mason6702ed42007-08-07 16:15:09 -0400401 return err;
402}
403
Chris Mason35b7e472007-05-02 15:53:43 -0400404static int drop_dirty_roots(struct btrfs_root *tree_root,
405 struct list_head *list)
Chris Mason0f7d52f2007-04-09 10:42:37 -0400406{
407 struct dirty_root *dirty;
408 struct btrfs_trans_handle *trans;
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400409 unsigned long nr;
Josef Bacik58176a92007-08-29 15:47:34 -0400410 u64 num_blocks;
411 u64 blocks_used;
Chris Mason54aa1f42007-06-22 14:16:25 -0400412 int ret = 0;
Chris Mason9f3a7422007-08-07 15:52:19 -0400413 int err;
414
Chris Mason0f7d52f2007-04-09 10:42:37 -0400415 while(!list_empty(list)) {
Josef Bacik58176a92007-08-29 15:47:34 -0400416 struct btrfs_root *root;
417
Chris Masonfacda1e2007-06-08 18:11:48 -0400418 mutex_lock(&tree_root->fs_info->fs_mutex);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400419 dirty = list_entry(list->next, struct dirty_root, list);
420 list_del_init(&dirty->list);
Chris Mason5eda7b52007-06-22 14:16:25 -0400421
Chris Mason5f39d392007-10-15 16:14:19 -0400422 num_blocks = btrfs_root_used(&dirty->root->root_item);
Josef Bacik58176a92007-08-29 15:47:34 -0400423 root = dirty->latest_root;
424
Chris Mason9f3a7422007-08-07 15:52:19 -0400425 while(1) {
426 trans = btrfs_start_transaction(tree_root, 1);
427 ret = btrfs_drop_snapshot(trans, dirty->root);
428 if (ret != -EAGAIN) {
429 break;
430 }
Josef Bacik58176a92007-08-29 15:47:34 -0400431
Chris Mason9f3a7422007-08-07 15:52:19 -0400432 err = btrfs_update_root(trans,
433 tree_root,
434 &dirty->root->root_key,
435 &dirty->root->root_item);
436 if (err)
437 ret = err;
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400438 nr = trans->blocks_used;
Chris Mason9f3a7422007-08-07 15:52:19 -0400439 ret = btrfs_end_transaction(trans, tree_root);
440 BUG_ON(ret);
Chris Masonf4468e92007-08-08 10:08:58 -0400441 mutex_unlock(&tree_root->fs_info->fs_mutex);
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400442 btrfs_btree_balance_dirty(tree_root, nr);
Chris Masonf4468e92007-08-08 10:08:58 -0400443 schedule();
444
445 mutex_lock(&tree_root->fs_info->fs_mutex);
Chris Mason9f3a7422007-08-07 15:52:19 -0400446 }
Chris Mason0f7d52f2007-04-09 10:42:37 -0400447 BUG_ON(ret);
Josef Bacik58176a92007-08-29 15:47:34 -0400448
Chris Mason5f39d392007-10-15 16:14:19 -0400449 num_blocks -= btrfs_root_used(&dirty->root->root_item);
450 blocks_used = btrfs_root_used(&root->root_item);
Josef Bacik58176a92007-08-29 15:47:34 -0400451 if (num_blocks) {
452 record_root_in_trans(root);
Chris Mason5f39d392007-10-15 16:14:19 -0400453 btrfs_set_root_used(&root->root_item,
Josef Bacik58176a92007-08-29 15:47:34 -0400454 blocks_used - num_blocks);
455 }
Chris Mason9f3a7422007-08-07 15:52:19 -0400456 ret = btrfs_del_root(trans, tree_root, &dirty->root->root_key);
Josef Bacik58176a92007-08-29 15:47:34 -0400457 if (ret) {
458 BUG();
Chris Mason54aa1f42007-06-22 14:16:25 -0400459 break;
Josef Bacik58176a92007-08-29 15:47:34 -0400460 }
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400461 nr = trans->blocks_used;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400462 ret = btrfs_end_transaction(trans, tree_root);
463 BUG_ON(ret);
Chris Mason5eda7b52007-06-22 14:16:25 -0400464
Chris Masonf510cfe2007-10-15 16:14:48 -0400465 free_extent_buffer(dirty->root->node);
Chris Mason9f3a7422007-08-07 15:52:19 -0400466 kfree(dirty->root);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400467 kfree(dirty);
Chris Masonfacda1e2007-06-08 18:11:48 -0400468 mutex_unlock(&tree_root->fs_info->fs_mutex);
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400469
470 btrfs_btree_balance_dirty(tree_root, nr);
Chris Masonf4468e92007-08-08 10:08:58 -0400471 schedule();
Chris Mason0f7d52f2007-04-09 10:42:37 -0400472 }
Chris Mason54aa1f42007-06-22 14:16:25 -0400473 return ret;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400474}
475
Chris Mason79154b12007-03-22 15:59:16 -0400476int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
477 struct btrfs_root *root)
478{
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400479 unsigned long joined = 0;
480 unsigned long timeout = 1;
Chris Mason79154b12007-03-22 15:59:16 -0400481 struct btrfs_transaction *cur_trans;
Chris Mason8fd17792007-04-19 21:01:03 -0400482 struct btrfs_transaction *prev_trans = NULL;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400483 struct list_head dirty_fs_roots;
Chris Masonccd467d2007-06-28 15:57:36 -0400484 struct radix_tree_root pinned_copy;
Chris Mason79154b12007-03-22 15:59:16 -0400485 DEFINE_WAIT(wait);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400486 int ret;
Chris Mason79154b12007-03-22 15:59:16 -0400487
Chris Masonccd467d2007-06-28 15:57:36 -0400488 init_bit_radix(&pinned_copy);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400489 INIT_LIST_HEAD(&dirty_fs_roots);
Chris Masond6e4a422007-04-06 15:37:36 -0400490
Chris Mason79154b12007-03-22 15:59:16 -0400491 mutex_lock(&root->fs_info->trans_mutex);
492 if (trans->transaction->in_commit) {
493 cur_trans = trans->transaction;
494 trans->transaction->use_count++;
Chris Masonccd467d2007-06-28 15:57:36 -0400495 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400496 btrfs_end_transaction(trans, root);
Chris Masonccd467d2007-06-28 15:57:36 -0400497
498 mutex_unlock(&root->fs_info->fs_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400499 ret = wait_for_commit(root, cur_trans);
500 BUG_ON(ret);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400501
502 mutex_lock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400503 put_transaction(cur_trans);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400504 mutex_unlock(&root->fs_info->trans_mutex);
505
Chris Masonccd467d2007-06-28 15:57:36 -0400506 mutex_lock(&root->fs_info->fs_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400507 return 0;
508 }
Chris Mason2c90e5d2007-04-02 10:50:19 -0400509 trans->transaction->in_commit = 1;
Chris Masonccd467d2007-06-28 15:57:36 -0400510 cur_trans = trans->transaction;
511 if (cur_trans->list.prev != &root->fs_info->trans_list) {
512 prev_trans = list_entry(cur_trans->list.prev,
513 struct btrfs_transaction, list);
514 if (!prev_trans->commit_done) {
515 prev_trans->use_count++;
516 mutex_unlock(&root->fs_info->fs_mutex);
517 mutex_unlock(&root->fs_info->trans_mutex);
518
519 wait_for_commit(root, prev_trans);
Chris Masonccd467d2007-06-28 15:57:36 -0400520
521 mutex_lock(&root->fs_info->fs_mutex);
522 mutex_lock(&root->fs_info->trans_mutex);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400523 put_transaction(prev_trans);
Chris Masonccd467d2007-06-28 15:57:36 -0400524 }
525 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400526
527 do {
528 joined = cur_trans->num_joined;
Chris Mason2c90e5d2007-04-02 10:50:19 -0400529 WARN_ON(cur_trans != trans->transaction);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400530 prepare_to_wait(&cur_trans->writer_wait, &wait,
Chris Mason79154b12007-03-22 15:59:16 -0400531 TASK_UNINTERRUPTIBLE);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400532
533 if (cur_trans->num_writers > 1)
534 timeout = MAX_SCHEDULE_TIMEOUT;
535 else
536 timeout = 1;
537
Chris Masonccd467d2007-06-28 15:57:36 -0400538 mutex_unlock(&root->fs_info->fs_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400539 mutex_unlock(&root->fs_info->trans_mutex);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400540
541 schedule_timeout(timeout);
542
Chris Masonccd467d2007-06-28 15:57:36 -0400543 mutex_lock(&root->fs_info->fs_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400544 mutex_lock(&root->fs_info->trans_mutex);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400545 finish_wait(&cur_trans->writer_wait, &wait);
546 } while (cur_trans->num_writers > 1 ||
547 (cur_trans->num_joined != joined));
548
Chris Mason2c90e5d2007-04-02 10:50:19 -0400549 WARN_ON(cur_trans != trans->transaction);
Chris Mason54aa1f42007-06-22 14:16:25 -0400550 ret = add_dirty_roots(trans, &root->fs_info->fs_roots_radix,
551 &dirty_fs_roots);
552 BUG_ON(ret);
553
Chris Mason79154b12007-03-22 15:59:16 -0400554 ret = btrfs_commit_tree_roots(trans, root);
555 BUG_ON(ret);
Chris Mason54aa1f42007-06-22 14:16:25 -0400556
Chris Mason78fae272007-03-25 11:35:08 -0400557 cur_trans = root->fs_info->running_transaction;
558 root->fs_info->running_transaction = NULL;
Chris Mason4b52dff2007-06-26 10:06:50 -0400559 btrfs_set_super_generation(&root->fs_info->super_copy,
560 cur_trans->transid);
561 btrfs_set_super_root(&root->fs_info->super_copy,
Chris Mason5f39d392007-10-15 16:14:19 -0400562 extent_buffer_blocknr(root->fs_info->tree_root->node));
563
564 write_extent_buffer(root->fs_info->sb_buffer,
565 &root->fs_info->super_copy, 0,
566 sizeof(root->fs_info->super_copy));
Chris Masonccd467d2007-06-28 15:57:36 -0400567
568 btrfs_copy_pinned(root, &pinned_copy);
569
Chris Mason78fae272007-03-25 11:35:08 -0400570 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason8fd17792007-04-19 21:01:03 -0400571 mutex_unlock(&root->fs_info->fs_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400572 ret = btrfs_write_and_wait_transaction(trans, root);
573 BUG_ON(ret);
Chris Mason79154b12007-03-22 15:59:16 -0400574 write_ctree_super(trans, root);
Chris Mason8fd17792007-04-19 21:01:03 -0400575 mutex_lock(&root->fs_info->fs_mutex);
Chris Masonccd467d2007-06-28 15:57:36 -0400576 btrfs_finish_extent_commit(trans, root, &pinned_copy);
Chris Mason78fae272007-03-25 11:35:08 -0400577 mutex_lock(&root->fs_info->trans_mutex);
Chris Mason2c90e5d2007-04-02 10:50:19 -0400578 cur_trans->commit_done = 1;
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400579 root->fs_info->last_trans_committed = cur_trans->transid;
Chris Mason2c90e5d2007-04-02 10:50:19 -0400580 wake_up(&cur_trans->commit_wait);
Chris Mason79154b12007-03-22 15:59:16 -0400581 put_transaction(cur_trans);
Chris Mason78fae272007-03-25 11:35:08 -0400582 put_transaction(cur_trans);
Josef Bacik58176a92007-08-29 15:47:34 -0400583
Chris Masonfacda1e2007-06-08 18:11:48 -0400584 if (root->fs_info->closing)
585 list_splice_init(&root->fs_info->dead_roots, &dirty_fs_roots);
586 else
587 list_splice_init(&dirty_fs_roots, &root->fs_info->dead_roots);
Josef Bacik58176a92007-08-29 15:47:34 -0400588
Chris Mason78fae272007-03-25 11:35:08 -0400589 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason2c90e5d2007-04-02 10:50:19 -0400590 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Chris Mason79154b12007-03-22 15:59:16 -0400591
Chris Masonfacda1e2007-06-08 18:11:48 -0400592 if (root->fs_info->closing) {
593 mutex_unlock(&root->fs_info->fs_mutex);
594 drop_dirty_roots(root->fs_info->tree_root, &dirty_fs_roots);
595 mutex_lock(&root->fs_info->fs_mutex);
596 }
Chris Mason79154b12007-03-22 15:59:16 -0400597 return ret;
598}
599
Chris Masone9d0b132007-08-10 14:06:19 -0400600int btrfs_clean_old_snapshots(struct btrfs_root *root)
601{
602 struct list_head dirty_roots;
603 INIT_LIST_HEAD(&dirty_roots);
604
605 mutex_lock(&root->fs_info->trans_mutex);
606 list_splice_init(&root->fs_info->dead_roots, &dirty_roots);
607 mutex_unlock(&root->fs_info->trans_mutex);
608
609 if (!list_empty(&dirty_roots)) {
610 drop_dirty_roots(root, &dirty_roots);
611 }
612 return 0;
613}
Chris Mason08607c12007-06-08 15:33:54 -0400614void btrfs_transaction_cleaner(struct work_struct *work)
615{
616 struct btrfs_fs_info *fs_info = container_of(work,
617 struct btrfs_fs_info,
618 trans_work.work);
619
620 struct btrfs_root *root = fs_info->tree_root;
621 struct btrfs_transaction *cur;
622 struct btrfs_trans_handle *trans;
623 unsigned long now;
624 unsigned long delay = HZ * 30;
625 int ret;
626
Chris Mason08607c12007-06-08 15:33:54 -0400627 mutex_lock(&root->fs_info->fs_mutex);
628 mutex_lock(&root->fs_info->trans_mutex);
629 cur = root->fs_info->running_transaction;
630 if (!cur) {
631 mutex_unlock(&root->fs_info->trans_mutex);
632 goto out;
633 }
634 now = get_seconds();
635 if (now < cur->start_time || now - cur->start_time < 30) {
636 mutex_unlock(&root->fs_info->trans_mutex);
637 delay = HZ * 5;
638 goto out;
639 }
640 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason6702ed42007-08-07 16:15:09 -0400641 btrfs_defrag_dirty_roots(root->fs_info);
Chris Mason08607c12007-06-08 15:33:54 -0400642 trans = btrfs_start_transaction(root, 1);
643 ret = btrfs_commit_transaction(trans, root);
644out:
645 mutex_unlock(&root->fs_info->fs_mutex);
Chris Masone9d0b132007-08-10 14:06:19 -0400646 btrfs_clean_old_snapshots(root);
Chris Mason08607c12007-06-08 15:33:54 -0400647 btrfs_transaction_queue_work(root, delay);
648}
649
650void btrfs_transaction_queue_work(struct btrfs_root *root, int delay)
651{
652 queue_delayed_work(trans_wq, &root->fs_info->trans_work, delay);
653}
654
655void btrfs_transaction_flush_work(struct btrfs_root *root)
656{
657 cancel_rearming_delayed_workqueue(trans_wq, &root->fs_info->trans_work);
658 flush_workqueue(trans_wq);
659}
660
661void __init btrfs_init_transaction_sys(void)
662{
663 trans_wq = create_workqueue("btrfs");
664}
665
666void __exit btrfs_exit_transaction_sys(void)
667{
668 destroy_workqueue(trans_wq);
669}
670