blob: dc9865323e38ea73253afdd331ba19929fa43175 [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 Mason3063d292008-01-08 15:46:30 -050069 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
Chris Mason8fd17792007-04-19 21:01:03 -040070 list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
Chris Masondc17ff82008-01-08 15:46:30 -050071 btrfs_ordered_inode_tree_init(&cur_trans->ordered_inode_tree);
Chris Mason5f39d392007-10-15 16:14:19 -040072 extent_map_tree_init(&cur_trans->dirty_pages,
73 root->fs_info->btree_inode->i_mapping,
74 GFP_NOFS);
Josef Bacik15ee9bc2007-08-10 16:22:09 -040075 } else {
76 cur_trans->num_writers++;
77 cur_trans->num_joined++;
Chris Mason79154b12007-03-22 15:59:16 -040078 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -040079
Chris Mason79154b12007-03-22 15:59:16 -040080 return 0;
81}
82
Chris Mason6702ed42007-08-07 16:15:09 -040083static int record_root_in_trans(struct btrfs_root *root)
84{
85 u64 running_trans_id = root->fs_info->running_transaction->transid;
86 if (root->ref_cows && root->last_trans < running_trans_id) {
87 WARN_ON(root == root->fs_info->extent_root);
88 if (root->root_item.refs != 0) {
89 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
90 (unsigned long)root->root_key.objectid,
91 BTRFS_ROOT_TRANS_TAG);
92 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
93 (unsigned long)root->root_key.objectid,
94 BTRFS_ROOT_DEFRAG_TAG);
95 root->commit_root = root->node;
Chris Mason5f39d392007-10-15 16:14:19 -040096 extent_buffer_get(root->node);
Chris Mason6702ed42007-08-07 16:15:09 -040097 } else {
98 WARN_ON(1);
99 }
100 root->last_trans = running_trans_id;
101 }
102 return 0;
103}
104
Chris Mason79154b12007-03-22 15:59:16 -0400105struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
106 int num_blocks)
107{
Chris Mason2c90e5d2007-04-02 10:50:19 -0400108 struct btrfs_trans_handle *h =
109 kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
Chris Mason79154b12007-03-22 15:59:16 -0400110 int ret;
111
112 mutex_lock(&root->fs_info->trans_mutex);
113 ret = join_transaction(root);
114 BUG_ON(ret);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400115
Chris Mason6702ed42007-08-07 16:15:09 -0400116 record_root_in_trans(root);
117 h->transid = root->fs_info->running_transaction->transid;
Chris Mason79154b12007-03-22 15:59:16 -0400118 h->transaction = root->fs_info->running_transaction;
119 h->blocks_reserved = num_blocks;
120 h->blocks_used = 0;
Chris Mason31f3c992007-04-30 15:25:45 -0400121 h->block_group = NULL;
Chris Mason26b80032007-08-08 20:17:12 -0400122 h->alloc_exclude_nr = 0;
123 h->alloc_exclude_start = 0;
Chris Mason79154b12007-03-22 15:59:16 -0400124 root->fs_info->running_transaction->use_count++;
125 mutex_unlock(&root->fs_info->trans_mutex);
126 return h;
127}
128
129int btrfs_end_transaction(struct btrfs_trans_handle *trans,
130 struct btrfs_root *root)
131{
132 struct btrfs_transaction *cur_trans;
Chris Masond6e4a422007-04-06 15:37:36 -0400133
Chris Mason79154b12007-03-22 15:59:16 -0400134 mutex_lock(&root->fs_info->trans_mutex);
135 cur_trans = root->fs_info->running_transaction;
Chris Masonccd467d2007-06-28 15:57:36 -0400136 WARN_ON(cur_trans != trans->transaction);
Chris Masond5719762007-03-23 10:01:08 -0400137 WARN_ON(cur_trans->num_writers < 1);
Chris Masonccd467d2007-06-28 15:57:36 -0400138 cur_trans->num_writers--;
Chris Mason79154b12007-03-22 15:59:16 -0400139 if (waitqueue_active(&cur_trans->writer_wait))
140 wake_up(&cur_trans->writer_wait);
Chris Mason79154b12007-03-22 15:59:16 -0400141 put_transaction(cur_trans);
142 mutex_unlock(&root->fs_info->trans_mutex);
Chris Masond6025572007-03-30 14:27:56 -0400143 memset(trans, 0, sizeof(*trans));
Chris Mason2c90e5d2007-04-02 10:50:19 -0400144 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Chris Mason79154b12007-03-22 15:59:16 -0400145 return 0;
146}
147
148
149int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
150 struct btrfs_root *root)
151{
Chris Mason7c4452b2007-04-28 09:29:35 -0400152 int ret;
Chris Mason7c4452b2007-04-28 09:29:35 -0400153 int err;
154 int werr = 0;
Chris Mason5f39d392007-10-15 16:14:19 -0400155 struct extent_map_tree *dirty_pages;
Chris Mason7c4452b2007-04-28 09:29:35 -0400156 struct page *page;
Chris Mason7c4452b2007-04-28 09:29:35 -0400157 struct inode *btree_inode = root->fs_info->btree_inode;
Chris Mason5f39d392007-10-15 16:14:19 -0400158 u64 start;
159 u64 end;
160 unsigned long index;
Chris Mason7c4452b2007-04-28 09:29:35 -0400161
162 if (!trans || !trans->transaction) {
163 return filemap_write_and_wait(btree_inode->i_mapping);
164 }
165 dirty_pages = &trans->transaction->dirty_pages;
166 while(1) {
Chris Mason5f39d392007-10-15 16:14:19 -0400167 ret = find_first_extent_bit(dirty_pages, 0, &start, &end,
168 EXTENT_DIRTY);
169 if (ret)
Chris Mason7c4452b2007-04-28 09:29:35 -0400170 break;
Chris Mason5f39d392007-10-15 16:14:19 -0400171 clear_extent_dirty(dirty_pages, start, end, GFP_NOFS);
172 while(start <= end) {
173 index = start >> PAGE_CACHE_SHIFT;
Chris Mason35ebb932007-10-30 16:56:53 -0400174 start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
Chris Mason5f39d392007-10-15 16:14:19 -0400175 page = find_lock_page(btree_inode->i_mapping, index);
Chris Mason7c4452b2007-04-28 09:29:35 -0400176 if (!page)
177 continue;
Chris Mason6702ed42007-08-07 16:15:09 -0400178 if (PageWriteback(page)) {
179 if (PageDirty(page))
180 wait_on_page_writeback(page);
181 else {
182 unlock_page(page);
183 page_cache_release(page);
184 continue;
185 }
186 }
Chris Mason7c4452b2007-04-28 09:29:35 -0400187 err = write_one_page(page, 0);
188 if (err)
189 werr = err;
190 page_cache_release(page);
191 }
192 }
193 err = filemap_fdatawait(btree_inode->i_mapping);
194 if (err)
195 werr = err;
196 return werr;
Chris Mason79154b12007-03-22 15:59:16 -0400197}
198
199int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans,
200 struct btrfs_root *root)
201{
202 int ret;
203 u64 old_extent_block;
204 struct btrfs_fs_info *fs_info = root->fs_info;
205 struct btrfs_root *tree_root = fs_info->tree_root;
206 struct btrfs_root *extent_root = fs_info->extent_root;
Chris Mason79154b12007-03-22 15:59:16 -0400207
Chris Mason9078a3e2007-04-26 16:46:15 -0400208 btrfs_write_dirty_block_groups(trans, extent_root);
Chris Mason79154b12007-03-22 15:59:16 -0400209 while(1) {
Chris Masondb945352007-10-15 16:15:53 -0400210 old_extent_block = btrfs_root_bytenr(&extent_root->root_item);
211 if (old_extent_block == extent_root->node->start)
Chris Mason79154b12007-03-22 15:59:16 -0400212 break;
Chris Masondb945352007-10-15 16:15:53 -0400213 btrfs_set_root_bytenr(&extent_root->root_item,
214 extent_root->node->start);
215 btrfs_set_root_level(&extent_root->root_item,
216 btrfs_header_level(extent_root->node));
Chris Mason79154b12007-03-22 15:59:16 -0400217 ret = btrfs_update_root(trans, tree_root,
218 &extent_root->root_key,
219 &extent_root->root_item);
220 BUG_ON(ret);
Chris Mason9078a3e2007-04-26 16:46:15 -0400221 btrfs_write_dirty_block_groups(trans, extent_root);
Chris Mason79154b12007-03-22 15:59:16 -0400222 }
223 return 0;
224}
225
226static int wait_for_commit(struct btrfs_root *root,
227 struct btrfs_transaction *commit)
228{
229 DEFINE_WAIT(wait);
Chris Masonccd467d2007-06-28 15:57:36 -0400230 mutex_lock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400231 while(!commit->commit_done) {
232 prepare_to_wait(&commit->commit_wait, &wait,
233 TASK_UNINTERRUPTIBLE);
234 if (commit->commit_done)
235 break;
236 mutex_unlock(&root->fs_info->trans_mutex);
237 schedule();
238 mutex_lock(&root->fs_info->trans_mutex);
239 }
Chris Masonccd467d2007-06-28 15:57:36 -0400240 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400241 finish_wait(&commit->commit_wait, &wait);
242 return 0;
243}
244
Chris Mason0f7d52f2007-04-09 10:42:37 -0400245struct dirty_root {
246 struct list_head list;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400247 struct btrfs_root *root;
Josef Bacik58176a92007-08-29 15:47:34 -0400248 struct btrfs_root *latest_root;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400249};
250
Chris Mason5ce14bb2007-09-11 11:15:39 -0400251int btrfs_add_dead_root(struct btrfs_root *root,
252 struct btrfs_root *latest,
253 struct list_head *dead_list)
Chris Mason5eda7b52007-06-22 14:16:25 -0400254{
255 struct dirty_root *dirty;
256
257 dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
258 if (!dirty)
259 return -ENOMEM;
Chris Mason5eda7b52007-06-22 14:16:25 -0400260 dirty->root = root;
Chris Mason5ce14bb2007-09-11 11:15:39 -0400261 dirty->latest_root = latest;
Chris Mason5eda7b52007-06-22 14:16:25 -0400262 list_add(&dirty->list, dead_list);
263 return 0;
264}
265
Chris Mason35b7e472007-05-02 15:53:43 -0400266static int add_dirty_roots(struct btrfs_trans_handle *trans,
267 struct radix_tree_root *radix,
268 struct list_head *list)
Chris Mason0f7d52f2007-04-09 10:42:37 -0400269{
270 struct dirty_root *dirty;
271 struct btrfs_root *gang[8];
272 struct btrfs_root *root;
273 int i;
274 int ret;
Chris Mason54aa1f42007-06-22 14:16:25 -0400275 int err = 0;
Chris Mason5eda7b52007-06-22 14:16:25 -0400276 u32 refs;
Chris Mason54aa1f42007-06-22 14:16:25 -0400277
Chris Mason0f7d52f2007-04-09 10:42:37 -0400278 while(1) {
279 ret = radix_tree_gang_lookup_tag(radix, (void **)gang, 0,
280 ARRAY_SIZE(gang),
281 BTRFS_ROOT_TRANS_TAG);
282 if (ret == 0)
283 break;
284 for (i = 0; i < ret; i++) {
285 root = gang[i];
Chris Mason2619ba12007-04-10 16:58:11 -0400286 radix_tree_tag_clear(radix,
287 (unsigned long)root->root_key.objectid,
288 BTRFS_ROOT_TRANS_TAG);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400289 if (root->commit_root == root->node) {
Chris Masondb945352007-10-15 16:15:53 -0400290 WARN_ON(root->node->start !=
291 btrfs_root_bytenr(&root->root_item));
Chris Mason5f39d392007-10-15 16:14:19 -0400292 free_extent_buffer(root->commit_root);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400293 root->commit_root = NULL;
Josef Bacik58176a92007-08-29 15:47:34 -0400294
295 /* make sure to update the root on disk
296 * so we get any updates to the block used
297 * counts
298 */
299 err = btrfs_update_root(trans,
300 root->fs_info->tree_root,
301 &root->root_key,
302 &root->root_item);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400303 continue;
304 }
305 dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
306 BUG_ON(!dirty);
Chris Mason9f3a7422007-08-07 15:52:19 -0400307 dirty->root = kmalloc(sizeof(*dirty->root), GFP_NOFS);
308 BUG_ON(!dirty->root);
309
310 memset(&root->root_item.drop_progress, 0,
311 sizeof(struct btrfs_disk_key));
312 root->root_item.drop_level = 0;
313
314 memcpy(dirty->root, root, sizeof(*root));
315 dirty->root->node = root->commit_root;
Josef Bacik58176a92007-08-29 15:47:34 -0400316 dirty->latest_root = root;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400317 root->commit_root = NULL;
Chris Mason5eda7b52007-06-22 14:16:25 -0400318
Chris Mason0f7d52f2007-04-09 10:42:37 -0400319 root->root_key.offset = root->fs_info->generation;
Chris Masondb945352007-10-15 16:15:53 -0400320 btrfs_set_root_bytenr(&root->root_item,
321 root->node->start);
322 btrfs_set_root_level(&root->root_item,
323 btrfs_header_level(root->node));
Chris Mason0f7d52f2007-04-09 10:42:37 -0400324 err = btrfs_insert_root(trans, root->fs_info->tree_root,
325 &root->root_key,
326 &root->root_item);
Chris Mason54aa1f42007-06-22 14:16:25 -0400327 if (err)
328 break;
Chris Mason9f3a7422007-08-07 15:52:19 -0400329
330 refs = btrfs_root_refs(&dirty->root->root_item);
331 btrfs_set_root_refs(&dirty->root->root_item, refs - 1);
Chris Mason5eda7b52007-06-22 14:16:25 -0400332 err = btrfs_update_root(trans, root->fs_info->tree_root,
Chris Mason9f3a7422007-08-07 15:52:19 -0400333 &dirty->root->root_key,
334 &dirty->root->root_item);
Chris Mason5eda7b52007-06-22 14:16:25 -0400335
336 BUG_ON(err);
Chris Mason9f3a7422007-08-07 15:52:19 -0400337 if (refs == 1) {
Chris Mason5eda7b52007-06-22 14:16:25 -0400338 list_add(&dirty->list, list);
Chris Mason9f3a7422007-08-07 15:52:19 -0400339 } else {
340 WARN_ON(1);
341 kfree(dirty->root);
Chris Mason5eda7b52007-06-22 14:16:25 -0400342 kfree(dirty);
Chris Mason9f3a7422007-08-07 15:52:19 -0400343 }
Chris Mason0f7d52f2007-04-09 10:42:37 -0400344 }
345 }
Chris Mason54aa1f42007-06-22 14:16:25 -0400346 return err;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400347}
348
Chris Masone9d0b132007-08-10 14:06:19 -0400349int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
350{
351 struct btrfs_fs_info *info = root->fs_info;
352 int ret;
353 struct btrfs_trans_handle *trans;
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400354 unsigned long nr;
Chris Masone9d0b132007-08-10 14:06:19 -0400355
356 if (root->defrag_running)
357 return 0;
Chris Masone9d0b132007-08-10 14:06:19 -0400358 trans = btrfs_start_transaction(root, 1);
Chris Mason6b800532007-10-15 16:17:34 -0400359 while (1) {
Chris Masone9d0b132007-08-10 14:06:19 -0400360 root->defrag_running = 1;
361 ret = btrfs_defrag_leaves(trans, root, cacheonly);
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400362 nr = trans->blocks_used;
Chris Masone9d0b132007-08-10 14:06:19 -0400363 btrfs_end_transaction(trans, root);
364 mutex_unlock(&info->fs_mutex);
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400365 btrfs_btree_balance_dirty(info->tree_root, nr);
Chris Masone9d0b132007-08-10 14:06:19 -0400366 cond_resched();
367
368 mutex_lock(&info->fs_mutex);
369 trans = btrfs_start_transaction(root, 1);
370 if (ret != -EAGAIN)
371 break;
372 }
373 root->defrag_running = 0;
374 radix_tree_tag_clear(&info->fs_roots_radix,
375 (unsigned long)root->root_key.objectid,
376 BTRFS_ROOT_DEFRAG_TAG);
377 btrfs_end_transaction(trans, root);
378 return 0;
379}
380
Chris Mason6702ed42007-08-07 16:15:09 -0400381int btrfs_defrag_dirty_roots(struct btrfs_fs_info *info)
382{
383 struct btrfs_root *gang[1];
384 struct btrfs_root *root;
Chris Mason6702ed42007-08-07 16:15:09 -0400385 int i;
386 int ret;
387 int err = 0;
388 u64 last = 0;
389
Chris Mason6702ed42007-08-07 16:15:09 -0400390 while(1) {
391 ret = radix_tree_gang_lookup_tag(&info->fs_roots_radix,
392 (void **)gang, last,
393 ARRAY_SIZE(gang),
394 BTRFS_ROOT_DEFRAG_TAG);
395 if (ret == 0)
396 break;
397 for (i = 0; i < ret; i++) {
398 root = gang[i];
399 last = root->root_key.objectid + 1;
Chris Masonf510cfe2007-10-15 16:14:48 -0400400 btrfs_defrag_root(root, 1);
Chris Mason6702ed42007-08-07 16:15:09 -0400401 }
402 }
Chris Mason6b800532007-10-15 16:17:34 -0400403 btrfs_defrag_root(info->extent_root, 1);
Chris Mason6702ed42007-08-07 16:15:09 -0400404 return err;
405}
406
Chris Mason35b7e472007-05-02 15:53:43 -0400407static int drop_dirty_roots(struct btrfs_root *tree_root,
408 struct list_head *list)
Chris Mason0f7d52f2007-04-09 10:42:37 -0400409{
410 struct dirty_root *dirty;
411 struct btrfs_trans_handle *trans;
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400412 unsigned long nr;
Chris Masondb945352007-10-15 16:15:53 -0400413 u64 num_bytes;
414 u64 bytes_used;
Chris Mason54aa1f42007-06-22 14:16:25 -0400415 int ret = 0;
Chris Mason9f3a7422007-08-07 15:52:19 -0400416 int err;
417
Chris Mason0f7d52f2007-04-09 10:42:37 -0400418 while(!list_empty(list)) {
Josef Bacik58176a92007-08-29 15:47:34 -0400419 struct btrfs_root *root;
420
Chris Masonfacda1e2007-06-08 18:11:48 -0400421 mutex_lock(&tree_root->fs_info->fs_mutex);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400422 dirty = list_entry(list->next, struct dirty_root, list);
423 list_del_init(&dirty->list);
Chris Mason5eda7b52007-06-22 14:16:25 -0400424
Chris Masondb945352007-10-15 16:15:53 -0400425 num_bytes = btrfs_root_used(&dirty->root->root_item);
Josef Bacik58176a92007-08-29 15:47:34 -0400426 root = dirty->latest_root;
427
Chris Mason9f3a7422007-08-07 15:52:19 -0400428 while(1) {
429 trans = btrfs_start_transaction(tree_root, 1);
430 ret = btrfs_drop_snapshot(trans, dirty->root);
431 if (ret != -EAGAIN) {
432 break;
433 }
Josef Bacik58176a92007-08-29 15:47:34 -0400434
Chris Mason9f3a7422007-08-07 15:52:19 -0400435 err = btrfs_update_root(trans,
436 tree_root,
437 &dirty->root->root_key,
438 &dirty->root->root_item);
439 if (err)
440 ret = err;
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400441 nr = trans->blocks_used;
Chris Mason9f3a7422007-08-07 15:52:19 -0400442 ret = btrfs_end_transaction(trans, tree_root);
443 BUG_ON(ret);
Chris Masonf4468e92007-08-08 10:08:58 -0400444 mutex_unlock(&tree_root->fs_info->fs_mutex);
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400445 btrfs_btree_balance_dirty(tree_root, nr);
Chris Mason4dc119042007-10-15 16:18:14 -0400446 cond_resched();
Chris Masonf4468e92007-08-08 10:08:58 -0400447 mutex_lock(&tree_root->fs_info->fs_mutex);
Chris Mason9f3a7422007-08-07 15:52:19 -0400448 }
Chris Mason0f7d52f2007-04-09 10:42:37 -0400449 BUG_ON(ret);
Josef Bacik58176a92007-08-29 15:47:34 -0400450
Chris Masondb945352007-10-15 16:15:53 -0400451 num_bytes -= btrfs_root_used(&dirty->root->root_item);
452 bytes_used = btrfs_root_used(&root->root_item);
453 if (num_bytes) {
Josef Bacik58176a92007-08-29 15:47:34 -0400454 record_root_in_trans(root);
Chris Mason5f39d392007-10-15 16:14:19 -0400455 btrfs_set_root_used(&root->root_item,
Chris Masondb945352007-10-15 16:15:53 -0400456 bytes_used - num_bytes);
Josef Bacik58176a92007-08-29 15:47:34 -0400457 }
Chris Mason9f3a7422007-08-07 15:52:19 -0400458 ret = btrfs_del_root(trans, tree_root, &dirty->root->root_key);
Josef Bacik58176a92007-08-29 15:47:34 -0400459 if (ret) {
460 BUG();
Chris Mason54aa1f42007-06-22 14:16:25 -0400461 break;
Josef Bacik58176a92007-08-29 15:47:34 -0400462 }
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400463 nr = trans->blocks_used;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400464 ret = btrfs_end_transaction(trans, tree_root);
465 BUG_ON(ret);
Chris Mason5eda7b52007-06-22 14:16:25 -0400466
Chris Masonf510cfe2007-10-15 16:14:48 -0400467 free_extent_buffer(dirty->root->node);
Chris Mason9f3a7422007-08-07 15:52:19 -0400468 kfree(dirty->root);
Chris Mason0f7d52f2007-04-09 10:42:37 -0400469 kfree(dirty);
Chris Masonfacda1e2007-06-08 18:11:48 -0400470 mutex_unlock(&tree_root->fs_info->fs_mutex);
Chris Masond3c2fdcf2007-09-17 10:58:06 -0400471
472 btrfs_btree_balance_dirty(tree_root, nr);
Chris Mason4dc119042007-10-15 16:18:14 -0400473 cond_resched();
Chris Mason0f7d52f2007-04-09 10:42:37 -0400474 }
Chris Mason54aa1f42007-06-22 14:16:25 -0400475 return ret;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400476}
477
Chris Masondc17ff82008-01-08 15:46:30 -0500478int btrfs_write_ordered_inodes(struct btrfs_trans_handle *trans,
479 struct btrfs_root *root)
480{
481 struct btrfs_transaction *cur_trans = trans->transaction;
482 struct inode *inode;
483 u64 root_objectid = 0;
484 u64 objectid = 0;
Chris Masondc17ff82008-01-08 15:46:30 -0500485 int ret;
486
Chris Masondc17ff82008-01-08 15:46:30 -0500487 while(1) {
488 ret = btrfs_find_first_ordered_inode(
489 &cur_trans->ordered_inode_tree,
490 &root_objectid, &objectid);
491 if (!ret)
492 break;
493
494 mutex_unlock(&root->fs_info->trans_mutex);
495 mutex_unlock(&root->fs_info->fs_mutex);
496 inode = btrfs_ilookup(root->fs_info->sb, objectid,
497 root_objectid);
498 if (inode) {
499 if (S_ISREG(inode->i_mode))
500 filemap_fdatawrite(inode->i_mapping);
501 iput(inode);
502 }
503 mutex_lock(&root->fs_info->fs_mutex);
504 mutex_lock(&root->fs_info->trans_mutex);
505 }
506 while(1) {
507 root_objectid = 0;
508 objectid = 0;
509 ret = btrfs_find_del_first_ordered_inode(
510 &cur_trans->ordered_inode_tree,
511 &root_objectid, &objectid);
512 if (!ret)
513 break;
514 mutex_unlock(&root->fs_info->trans_mutex);
515 mutex_unlock(&root->fs_info->fs_mutex);
516 inode = btrfs_ilookup(root->fs_info->sb, objectid,
517 root_objectid);
518 if (inode) {
519 if (S_ISREG(inode->i_mode))
520 filemap_write_and_wait(inode->i_mapping);
521 iput(inode);
522 }
523 mutex_lock(&root->fs_info->fs_mutex);
524 mutex_lock(&root->fs_info->trans_mutex);
525 }
Chris Mason3063d292008-01-08 15:46:30 -0500526 return 0;
527}
528
529static int create_pending_snapshot(struct btrfs_trans_handle *trans,
530 struct btrfs_fs_info *fs_info,
531 struct btrfs_pending_snapshot *pending)
532{
533 struct btrfs_key key;
534 struct btrfs_root_item new_root_item;
535 struct btrfs_root *tree_root = fs_info->tree_root;
536 struct btrfs_root *root = pending->root;
537 struct extent_buffer *tmp;
538 int ret;
539 u64 objectid;
540
541 ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid);
542 if (ret)
543 goto fail;
544
545 memcpy(&new_root_item, &root->root_item, sizeof(new_root_item));
546
547 key.objectid = objectid;
548 key.offset = 1;
549 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
550
551 extent_buffer_get(root->node);
552 btrfs_cow_block(trans, root, root->node, NULL, 0, &tmp);
553 free_extent_buffer(tmp);
554
555 btrfs_copy_root(trans, root, root->node, &tmp, objectid);
556
557 btrfs_set_root_bytenr(&new_root_item, tmp->start);
558 btrfs_set_root_level(&new_root_item, btrfs_header_level(tmp));
559 ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
560 &new_root_item);
561 free_extent_buffer(tmp);
562 if (ret)
563 goto fail;
564
565 /*
566 * insert the directory item
567 */
568 key.offset = (u64)-1;
569 ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
570 pending->name, strlen(pending->name),
571 root->fs_info->sb->s_root->d_inode->i_ino,
572 &key, BTRFS_FT_DIR);
573
574 if (ret)
575 goto fail;
576
577 ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root,
578 pending->name, strlen(pending->name), objectid,
579 root->fs_info->sb->s_root->d_inode->i_ino);
580fail:
581 return ret;
582}
583
584static int create_pending_snapshots(struct btrfs_trans_handle *trans,
585 struct btrfs_fs_info *fs_info)
586{
587 struct btrfs_pending_snapshot *pending;
588 struct list_head *head = &trans->transaction->pending_snapshots;
589 int ret;
590
591 while(!list_empty(head)) {
592 pending = list_entry(head->next,
593 struct btrfs_pending_snapshot, list);
594 ret = create_pending_snapshot(trans, fs_info, pending);
595 BUG_ON(ret);
596 list_del(&pending->list);
597 kfree(pending->name);
598 kfree(pending);
599 }
Chris Masondc17ff82008-01-08 15:46:30 -0500600 return 0;
601}
602
Chris Mason79154b12007-03-22 15:59:16 -0400603int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
604 struct btrfs_root *root)
605{
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400606 unsigned long joined = 0;
607 unsigned long timeout = 1;
Chris Mason79154b12007-03-22 15:59:16 -0400608 struct btrfs_transaction *cur_trans;
Chris Mason8fd17792007-04-19 21:01:03 -0400609 struct btrfs_transaction *prev_trans = NULL;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400610 struct list_head dirty_fs_roots;
Chris Mason4313b392008-01-03 09:08:48 -0500611 struct extent_map_tree *pinned_copy;
Chris Mason79154b12007-03-22 15:59:16 -0400612 DEFINE_WAIT(wait);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400613 int ret;
Chris Mason79154b12007-03-22 15:59:16 -0400614
Chris Mason0f7d52f2007-04-09 10:42:37 -0400615 INIT_LIST_HEAD(&dirty_fs_roots);
Chris Masond6e4a422007-04-06 15:37:36 -0400616
Chris Mason79154b12007-03-22 15:59:16 -0400617 mutex_lock(&root->fs_info->trans_mutex);
618 if (trans->transaction->in_commit) {
619 cur_trans = trans->transaction;
620 trans->transaction->use_count++;
Chris Masonccd467d2007-06-28 15:57:36 -0400621 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400622 btrfs_end_transaction(trans, root);
Chris Masonccd467d2007-06-28 15:57:36 -0400623
624 mutex_unlock(&root->fs_info->fs_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400625 ret = wait_for_commit(root, cur_trans);
626 BUG_ON(ret);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400627
628 mutex_lock(&root->fs_info->trans_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400629 put_transaction(cur_trans);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400630 mutex_unlock(&root->fs_info->trans_mutex);
631
Chris Masonccd467d2007-06-28 15:57:36 -0400632 mutex_lock(&root->fs_info->fs_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400633 return 0;
634 }
Chris Mason4313b392008-01-03 09:08:48 -0500635
636 pinned_copy = kmalloc(sizeof(*pinned_copy), GFP_NOFS);
637 if (!pinned_copy)
638 return -ENOMEM;
639
640 extent_map_tree_init(pinned_copy,
641 root->fs_info->btree_inode->i_mapping, GFP_NOFS);
642
Chris Mason2c90e5d2007-04-02 10:50:19 -0400643 trans->transaction->in_commit = 1;
Chris Masonccd467d2007-06-28 15:57:36 -0400644 cur_trans = trans->transaction;
645 if (cur_trans->list.prev != &root->fs_info->trans_list) {
646 prev_trans = list_entry(cur_trans->list.prev,
647 struct btrfs_transaction, list);
648 if (!prev_trans->commit_done) {
649 prev_trans->use_count++;
650 mutex_unlock(&root->fs_info->fs_mutex);
651 mutex_unlock(&root->fs_info->trans_mutex);
652
653 wait_for_commit(root, prev_trans);
Chris Masonccd467d2007-06-28 15:57:36 -0400654
655 mutex_lock(&root->fs_info->fs_mutex);
656 mutex_lock(&root->fs_info->trans_mutex);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400657 put_transaction(prev_trans);
Chris Masonccd467d2007-06-28 15:57:36 -0400658 }
659 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400660
661 do {
662 joined = cur_trans->num_joined;
Chris Mason2c90e5d2007-04-02 10:50:19 -0400663 WARN_ON(cur_trans != trans->transaction);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400664 prepare_to_wait(&cur_trans->writer_wait, &wait,
Chris Mason79154b12007-03-22 15:59:16 -0400665 TASK_UNINTERRUPTIBLE);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400666
667 if (cur_trans->num_writers > 1)
668 timeout = MAX_SCHEDULE_TIMEOUT;
669 else
670 timeout = 1;
671
Chris Masonccd467d2007-06-28 15:57:36 -0400672 mutex_unlock(&root->fs_info->fs_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400673 mutex_unlock(&root->fs_info->trans_mutex);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400674
675 schedule_timeout(timeout);
676
Chris Masonccd467d2007-06-28 15:57:36 -0400677 mutex_lock(&root->fs_info->fs_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400678 mutex_lock(&root->fs_info->trans_mutex);
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400679 finish_wait(&cur_trans->writer_wait, &wait);
Chris Masondc17ff82008-01-08 15:46:30 -0500680 ret = btrfs_write_ordered_inodes(trans, root);
681
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400682 } while (cur_trans->num_writers > 1 ||
683 (cur_trans->num_joined != joined));
684
Chris Mason3063d292008-01-08 15:46:30 -0500685 ret = create_pending_snapshots(trans, root->fs_info);
686 BUG_ON(ret);
687
Chris Mason2c90e5d2007-04-02 10:50:19 -0400688 WARN_ON(cur_trans != trans->transaction);
Chris Masondc17ff82008-01-08 15:46:30 -0500689
Chris Mason54aa1f42007-06-22 14:16:25 -0400690 ret = add_dirty_roots(trans, &root->fs_info->fs_roots_radix,
691 &dirty_fs_roots);
692 BUG_ON(ret);
693
Chris Mason79154b12007-03-22 15:59:16 -0400694 ret = btrfs_commit_tree_roots(trans, root);
695 BUG_ON(ret);
Chris Mason54aa1f42007-06-22 14:16:25 -0400696
Chris Mason78fae272007-03-25 11:35:08 -0400697 cur_trans = root->fs_info->running_transaction;
698 root->fs_info->running_transaction = NULL;
Chris Mason4b52dff2007-06-26 10:06:50 -0400699 btrfs_set_super_generation(&root->fs_info->super_copy,
700 cur_trans->transid);
701 btrfs_set_super_root(&root->fs_info->super_copy,
Chris Masondb945352007-10-15 16:15:53 -0400702 root->fs_info->tree_root->node->start);
703 btrfs_set_super_root_level(&root->fs_info->super_copy,
704 btrfs_header_level(root->fs_info->tree_root->node));
Chris Mason5f39d392007-10-15 16:14:19 -0400705
706 write_extent_buffer(root->fs_info->sb_buffer,
707 &root->fs_info->super_copy, 0,
708 sizeof(root->fs_info->super_copy));
Chris Masonccd467d2007-06-28 15:57:36 -0400709
Chris Mason4313b392008-01-03 09:08:48 -0500710 btrfs_copy_pinned(root, pinned_copy);
Chris Masonccd467d2007-06-28 15:57:36 -0400711
Chris Mason78fae272007-03-25 11:35:08 -0400712 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason8fd17792007-04-19 21:01:03 -0400713 mutex_unlock(&root->fs_info->fs_mutex);
Chris Mason79154b12007-03-22 15:59:16 -0400714 ret = btrfs_write_and_wait_transaction(trans, root);
715 BUG_ON(ret);
Chris Mason79154b12007-03-22 15:59:16 -0400716 write_ctree_super(trans, root);
Chris Mason4313b392008-01-03 09:08:48 -0500717
Chris Mason8fd17792007-04-19 21:01:03 -0400718 mutex_lock(&root->fs_info->fs_mutex);
Chris Mason4313b392008-01-03 09:08:48 -0500719 btrfs_finish_extent_commit(trans, root, pinned_copy);
Chris Mason78fae272007-03-25 11:35:08 -0400720 mutex_lock(&root->fs_info->trans_mutex);
Chris Mason4313b392008-01-03 09:08:48 -0500721
722 kfree(pinned_copy);
723
Chris Mason2c90e5d2007-04-02 10:50:19 -0400724 cur_trans->commit_done = 1;
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400725 root->fs_info->last_trans_committed = cur_trans->transid;
Chris Mason2c90e5d2007-04-02 10:50:19 -0400726 wake_up(&cur_trans->commit_wait);
Chris Mason79154b12007-03-22 15:59:16 -0400727 put_transaction(cur_trans);
Chris Mason78fae272007-03-25 11:35:08 -0400728 put_transaction(cur_trans);
Josef Bacik58176a92007-08-29 15:47:34 -0400729
Chris Masonfacda1e2007-06-08 18:11:48 -0400730 if (root->fs_info->closing)
731 list_splice_init(&root->fs_info->dead_roots, &dirty_fs_roots);
732 else
733 list_splice_init(&dirty_fs_roots, &root->fs_info->dead_roots);
Josef Bacik58176a92007-08-29 15:47:34 -0400734
Chris Mason78fae272007-03-25 11:35:08 -0400735 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason2c90e5d2007-04-02 10:50:19 -0400736 kmem_cache_free(btrfs_trans_handle_cachep, trans);
Chris Mason79154b12007-03-22 15:59:16 -0400737
Chris Masonfacda1e2007-06-08 18:11:48 -0400738 if (root->fs_info->closing) {
739 mutex_unlock(&root->fs_info->fs_mutex);
740 drop_dirty_roots(root->fs_info->tree_root, &dirty_fs_roots);
741 mutex_lock(&root->fs_info->fs_mutex);
742 }
Chris Mason79154b12007-03-22 15:59:16 -0400743 return ret;
744}
745
Chris Masone9d0b132007-08-10 14:06:19 -0400746int btrfs_clean_old_snapshots(struct btrfs_root *root)
747{
748 struct list_head dirty_roots;
749 INIT_LIST_HEAD(&dirty_roots);
750
751 mutex_lock(&root->fs_info->trans_mutex);
752 list_splice_init(&root->fs_info->dead_roots, &dirty_roots);
753 mutex_unlock(&root->fs_info->trans_mutex);
754
755 if (!list_empty(&dirty_roots)) {
756 drop_dirty_roots(root, &dirty_roots);
757 }
758 return 0;
759}
Chris Mason6da6aba2007-12-18 16:15:09 -0500760#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
761void btrfs_transaction_cleaner(void *p)
762#else
Chris Mason08607c12007-06-08 15:33:54 -0400763void btrfs_transaction_cleaner(struct work_struct *work)
Chris Mason6da6aba2007-12-18 16:15:09 -0500764#endif
Chris Mason08607c12007-06-08 15:33:54 -0400765{
Chris Mason6da6aba2007-12-18 16:15:09 -0500766#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
767 struct btrfs_fs_info *fs_info = p;
768#else
Chris Mason08607c12007-06-08 15:33:54 -0400769 struct btrfs_fs_info *fs_info = container_of(work,
770 struct btrfs_fs_info,
771 trans_work.work);
772
Chris Mason6da6aba2007-12-18 16:15:09 -0500773#endif
Chris Mason08607c12007-06-08 15:33:54 -0400774 struct btrfs_root *root = fs_info->tree_root;
775 struct btrfs_transaction *cur;
776 struct btrfs_trans_handle *trans;
777 unsigned long now;
778 unsigned long delay = HZ * 30;
779 int ret;
780
Chris Mason08607c12007-06-08 15:33:54 -0400781 mutex_lock(&root->fs_info->fs_mutex);
782 mutex_lock(&root->fs_info->trans_mutex);
783 cur = root->fs_info->running_transaction;
784 if (!cur) {
785 mutex_unlock(&root->fs_info->trans_mutex);
786 goto out;
787 }
788 now = get_seconds();
789 if (now < cur->start_time || now - cur->start_time < 30) {
790 mutex_unlock(&root->fs_info->trans_mutex);
791 delay = HZ * 5;
792 goto out;
793 }
794 mutex_unlock(&root->fs_info->trans_mutex);
Chris Mason6702ed42007-08-07 16:15:09 -0400795 btrfs_defrag_dirty_roots(root->fs_info);
Chris Mason08607c12007-06-08 15:33:54 -0400796 trans = btrfs_start_transaction(root, 1);
797 ret = btrfs_commit_transaction(trans, root);
798out:
799 mutex_unlock(&root->fs_info->fs_mutex);
Chris Masone9d0b132007-08-10 14:06:19 -0400800 btrfs_clean_old_snapshots(root);
Chris Mason08607c12007-06-08 15:33:54 -0400801 btrfs_transaction_queue_work(root, delay);
802}
803
804void btrfs_transaction_queue_work(struct btrfs_root *root, int delay)
805{
806 queue_delayed_work(trans_wq, &root->fs_info->trans_work, delay);
807}
808
809void btrfs_transaction_flush_work(struct btrfs_root *root)
810{
811 cancel_rearming_delayed_workqueue(trans_wq, &root->fs_info->trans_work);
812 flush_workqueue(trans_wq);
813}
814
815void __init btrfs_init_transaction_sys(void)
816{
817 trans_wq = create_workqueue("btrfs");
818}
819
Christian Hesse17636e02007-12-11 09:25:06 -0500820void btrfs_exit_transaction_sys(void)
Chris Mason08607c12007-06-08 15:33:54 -0400821{
822 destroy_workqueue(trans_wq);
823}
824