2007-06-12 15:07:21 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2007 Oracle. All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
* License v2 as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public
|
|
|
|
* License along with this program; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 021110-1307, USA.
|
|
|
|
*/
|
|
|
|
|
2007-03-22 20:59:16 +01:00
|
|
|
#include <linux/fs.h>
|
2007-06-12 17:36:58 +02:00
|
|
|
#include <linux/sched.h>
|
2007-09-17 16:58:06 +02:00
|
|
|
#include <linux/writeback.h>
|
2007-10-15 22:14:19 +02:00
|
|
|
#include <linux/pagemap.h>
|
2007-03-22 20:59:16 +01:00
|
|
|
#include "ctree.h"
|
|
|
|
#include "disk-io.h"
|
|
|
|
#include "transaction.h"
|
2008-06-25 22:01:30 +02:00
|
|
|
#include "locking.h"
|
2008-07-28 21:32:19 +02:00
|
|
|
#include "ref-cache.h"
|
2008-09-05 22:13:11 +02:00
|
|
|
#include "tree-log.h"
|
2007-03-22 20:59:16 +01:00
|
|
|
|
2007-03-25 17:35:08 +02:00
|
|
|
static int total_trans = 0;
|
2007-04-02 16:50:19 +02:00
|
|
|
extern struct kmem_cache *btrfs_trans_handle_cachep;
|
|
|
|
extern struct kmem_cache *btrfs_transaction_cachep;
|
|
|
|
|
2007-04-09 16:42:37 +02:00
|
|
|
#define BTRFS_ROOT_TRANS_TAG 0
|
|
|
|
|
2008-02-01 22:35:04 +01:00
|
|
|
static noinline void put_transaction(struct btrfs_transaction *transaction)
|
2007-03-22 20:59:16 +01:00
|
|
|
{
|
2007-04-02 16:50:19 +02:00
|
|
|
WARN_ON(transaction->use_count == 0);
|
2007-03-22 20:59:16 +01:00
|
|
|
transaction->use_count--;
|
2007-03-25 17:35:08 +02:00
|
|
|
if (transaction->use_count == 0) {
|
|
|
|
WARN_ON(total_trans == 0);
|
|
|
|
total_trans--;
|
2007-04-20 03:01:03 +02:00
|
|
|
list_del_init(&transaction->list);
|
2007-04-02 16:50:19 +02:00
|
|
|
memset(transaction, 0, sizeof(*transaction));
|
|
|
|
kmem_cache_free(btrfs_transaction_cachep, transaction);
|
2007-03-25 17:35:08 +02:00
|
|
|
}
|
2007-03-22 20:59:16 +01:00
|
|
|
}
|
|
|
|
|
2008-02-01 22:35:04 +01:00
|
|
|
static noinline int join_transaction(struct btrfs_root *root)
|
2007-03-22 20:59:16 +01:00
|
|
|
{
|
|
|
|
struct btrfs_transaction *cur_trans;
|
|
|
|
cur_trans = root->fs_info->running_transaction;
|
|
|
|
if (!cur_trans) {
|
2007-04-02 16:50:19 +02:00
|
|
|
cur_trans = kmem_cache_alloc(btrfs_transaction_cachep,
|
|
|
|
GFP_NOFS);
|
2007-03-25 17:35:08 +02:00
|
|
|
total_trans++;
|
2007-03-22 20:59:16 +01:00
|
|
|
BUG_ON(!cur_trans);
|
2007-04-09 16:42:37 +02:00
|
|
|
root->fs_info->generation++;
|
2008-01-18 16:54:22 +01:00
|
|
|
root->fs_info->last_alloc = 0;
|
2008-01-31 22:45:07 +01:00
|
|
|
root->fs_info->last_data_alloc = 0;
|
2008-09-05 22:13:11 +02:00
|
|
|
root->fs_info->last_log_alloc = 0;
|
2007-08-10 22:22:09 +02:00
|
|
|
cur_trans->num_writers = 1;
|
|
|
|
cur_trans->num_joined = 0;
|
2007-04-09 16:42:37 +02:00
|
|
|
cur_trans->transid = root->fs_info->generation;
|
2007-03-22 20:59:16 +01:00
|
|
|
init_waitqueue_head(&cur_trans->writer_wait);
|
|
|
|
init_waitqueue_head(&cur_trans->commit_wait);
|
|
|
|
cur_trans->in_commit = 0;
|
2008-07-17 18:54:14 +02:00
|
|
|
cur_trans->blocked = 0;
|
2007-03-23 15:01:08 +01:00
|
|
|
cur_trans->use_count = 1;
|
2007-03-22 20:59:16 +01:00
|
|
|
cur_trans->commit_done = 0;
|
2007-06-08 21:33:54 +02:00
|
|
|
cur_trans->start_time = get_seconds();
|
2008-01-08 21:46:30 +01:00
|
|
|
INIT_LIST_HEAD(&cur_trans->pending_snapshots);
|
2007-04-20 03:01:03 +02:00
|
|
|
list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
|
2008-01-24 22:13:08 +01:00
|
|
|
extent_io_tree_init(&cur_trans->dirty_pages,
|
2007-10-15 22:14:19 +02:00
|
|
|
root->fs_info->btree_inode->i_mapping,
|
|
|
|
GFP_NOFS);
|
2008-06-09 15:35:50 +02:00
|
|
|
spin_lock(&root->fs_info->new_trans_lock);
|
|
|
|
root->fs_info->running_transaction = cur_trans;
|
|
|
|
spin_unlock(&root->fs_info->new_trans_lock);
|
2007-08-10 22:22:09 +02:00
|
|
|
} else {
|
|
|
|
cur_trans->num_writers++;
|
|
|
|
cur_trans->num_joined++;
|
2007-03-22 20:59:16 +01:00
|
|
|
}
|
2007-08-10 22:22:09 +02:00
|
|
|
|
2007-03-22 20:59:16 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
noinline int btrfs_record_root_in_trans(struct btrfs_root *root)
|
2007-08-07 22:15:09 +02:00
|
|
|
{
|
2008-07-30 15:26:11 +02:00
|
|
|
struct btrfs_dirty_root *dirty;
|
2007-08-07 22:15:09 +02:00
|
|
|
u64 running_trans_id = root->fs_info->running_transaction->transid;
|
|
|
|
if (root->ref_cows && root->last_trans < running_trans_id) {
|
|
|
|
WARN_ON(root == root->fs_info->extent_root);
|
|
|
|
if (root->root_item.refs != 0) {
|
|
|
|
radix_tree_tag_set(&root->fs_info->fs_roots_radix,
|
|
|
|
(unsigned long)root->root_key.objectid,
|
|
|
|
BTRFS_ROOT_TRANS_TAG);
|
2008-07-28 21:32:19 +02:00
|
|
|
|
|
|
|
dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
|
|
|
|
BUG_ON(!dirty);
|
|
|
|
dirty->root = kmalloc(sizeof(*dirty->root), GFP_NOFS);
|
|
|
|
BUG_ON(!dirty->root);
|
|
|
|
dirty->latest_root = root;
|
|
|
|
INIT_LIST_HEAD(&dirty->list);
|
|
|
|
|
2008-06-25 22:01:30 +02:00
|
|
|
root->commit_root = btrfs_root_node(root);
|
2008-07-28 21:32:19 +02:00
|
|
|
|
|
|
|
memcpy(dirty->root, root, sizeof(*root));
|
|
|
|
spin_lock_init(&dirty->root->node_lock);
|
2008-07-30 22:29:20 +02:00
|
|
|
spin_lock_init(&dirty->root->list_lock);
|
2008-07-28 21:32:19 +02:00
|
|
|
mutex_init(&dirty->root->objectid_mutex);
|
2008-09-26 16:05:38 +02:00
|
|
|
mutex_init(&dirty->root->log_mutex);
|
2008-07-30 22:29:20 +02:00
|
|
|
INIT_LIST_HEAD(&dirty->root->dead_list);
|
2008-07-28 21:32:19 +02:00
|
|
|
dirty->root->node = root->commit_root;
|
|
|
|
dirty->root->commit_root = NULL;
|
2008-07-30 22:29:20 +02:00
|
|
|
|
|
|
|
spin_lock(&root->list_lock);
|
|
|
|
list_add(&dirty->root->dead_list, &root->dead_list);
|
|
|
|
spin_unlock(&root->list_lock);
|
|
|
|
|
|
|
|
root->dirty_root = dirty;
|
2007-08-07 22:15:09 +02:00
|
|
|
} else {
|
|
|
|
WARN_ON(1);
|
|
|
|
}
|
|
|
|
root->last_trans = running_trans_id;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-31 16:48:37 +02:00
|
|
|
static void wait_current_trans(struct btrfs_root *root)
|
2007-03-22 20:59:16 +01:00
|
|
|
{
|
2008-07-17 18:54:14 +02:00
|
|
|
struct btrfs_transaction *cur_trans;
|
2007-03-22 20:59:16 +01:00
|
|
|
|
2008-07-17 18:54:14 +02:00
|
|
|
cur_trans = root->fs_info->running_transaction;
|
2008-07-31 16:48:37 +02:00
|
|
|
if (cur_trans && cur_trans->blocked) {
|
2008-07-17 18:54:14 +02:00
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
cur_trans->use_count++;
|
|
|
|
while(1) {
|
|
|
|
prepare_to_wait(&root->fs_info->transaction_wait, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
if (cur_trans->blocked) {
|
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
|
|
|
schedule();
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
|
|
|
finish_wait(&root->fs_info->transaction_wait,
|
|
|
|
&wait);
|
|
|
|
} else {
|
|
|
|
finish_wait(&root->fs_info->transaction_wait,
|
|
|
|
&wait);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
put_transaction(cur_trans);
|
|
|
|
}
|
2008-07-31 16:48:37 +02:00
|
|
|
}
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
|
2008-08-04 16:41:27 +02:00
|
|
|
int num_blocks, int wait)
|
2008-07-31 16:48:37 +02:00
|
|
|
{
|
|
|
|
struct btrfs_trans_handle *h =
|
|
|
|
kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
2008-09-08 17:18:08 +02:00
|
|
|
if (!root->fs_info->log_root_recovering &&
|
|
|
|
((wait == 1 && !root->fs_info->open_ioctl_trans) || wait == 2))
|
2008-07-31 16:48:37 +02:00
|
|
|
wait_current_trans(root);
|
2007-03-22 20:59:16 +01:00
|
|
|
ret = join_transaction(root);
|
|
|
|
BUG_ON(ret);
|
2007-04-09 16:42:37 +02:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
btrfs_record_root_in_trans(root);
|
2007-08-07 22:15:09 +02:00
|
|
|
h->transid = root->fs_info->running_transaction->transid;
|
2007-03-22 20:59:16 +01:00
|
|
|
h->transaction = root->fs_info->running_transaction;
|
|
|
|
h->blocks_reserved = num_blocks;
|
|
|
|
h->blocks_used = 0;
|
2007-04-30 21:25:45 +02:00
|
|
|
h->block_group = NULL;
|
2007-08-09 02:17:12 +02:00
|
|
|
h->alloc_exclude_nr = 0;
|
|
|
|
h->alloc_exclude_start = 0;
|
2007-03-22 20:59:16 +01:00
|
|
|
root->fs_info->running_transaction->use_count++;
|
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
|
|
|
return h;
|
|
|
|
}
|
|
|
|
|
2008-07-17 18:54:14 +02:00
|
|
|
struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
|
|
|
|
int num_blocks)
|
|
|
|
{
|
2008-08-04 16:41:27 +02:00
|
|
|
return start_transaction(root, num_blocks, 1);
|
2008-07-17 18:54:14 +02:00
|
|
|
}
|
|
|
|
struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root,
|
|
|
|
int num_blocks)
|
|
|
|
{
|
2008-08-04 16:41:27 +02:00
|
|
|
return start_transaction(root, num_blocks, 0);
|
2008-07-17 18:54:14 +02:00
|
|
|
}
|
|
|
|
|
2008-08-04 16:41:27 +02:00
|
|
|
struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r,
|
|
|
|
int num_blocks)
|
|
|
|
{
|
|
|
|
return start_transaction(r, num_blocks, 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-06-25 22:01:31 +02:00
|
|
|
static noinline int wait_for_commit(struct btrfs_root *root,
|
|
|
|
struct btrfs_transaction *commit)
|
|
|
|
{
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
|
|
|
while(!commit->commit_done) {
|
|
|
|
prepare_to_wait(&commit->commit_wait, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
if (commit->commit_done)
|
|
|
|
break;
|
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
|
|
|
schedule();
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
|
|
|
}
|
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
|
|
|
finish_wait(&commit->commit_wait, &wait);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-31 16:48:37 +02:00
|
|
|
static void throttle_on_drops(struct btrfs_root *root)
|
2008-07-29 22:15:18 +02:00
|
|
|
{
|
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
2008-08-04 14:20:15 +02:00
|
|
|
int harder_count = 0;
|
2008-07-29 22:15:18 +02:00
|
|
|
|
2008-08-04 14:20:15 +02:00
|
|
|
harder:
|
2008-07-29 22:15:18 +02:00
|
|
|
if (atomic_read(&info->throttles)) {
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
int thr;
|
|
|
|
thr = atomic_read(&info->throttle_gen);
|
|
|
|
|
|
|
|
do {
|
|
|
|
prepare_to_wait(&info->transaction_throttle,
|
|
|
|
&wait, TASK_UNINTERRUPTIBLE);
|
|
|
|
if (!atomic_read(&info->throttles)) {
|
|
|
|
finish_wait(&info->transaction_throttle, &wait);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
schedule();
|
|
|
|
finish_wait(&info->transaction_throttle, &wait);
|
|
|
|
} while (thr == atomic_read(&info->throttle_gen));
|
2008-08-04 14:20:15 +02:00
|
|
|
harder_count++;
|
|
|
|
|
|
|
|
if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 &&
|
|
|
|
harder_count < 2)
|
|
|
|
goto harder;
|
|
|
|
|
|
|
|
if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 &&
|
|
|
|
harder_count < 10)
|
|
|
|
goto harder;
|
|
|
|
|
|
|
|
if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 &&
|
|
|
|
harder_count < 20)
|
|
|
|
goto harder;
|
2008-07-29 22:15:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-31 16:48:37 +02:00
|
|
|
void btrfs_throttle(struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
2008-08-04 16:41:27 +02:00
|
|
|
if (!root->fs_info->open_ioctl_trans)
|
|
|
|
wait_current_trans(root);
|
2008-07-31 16:48:37 +02:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
|
|
|
|
|
|
|
throttle_on_drops(root);
|
|
|
|
}
|
|
|
|
|
2008-06-25 22:01:31 +02:00
|
|
|
static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root, int throttle)
|
2007-03-22 20:59:16 +01:00
|
|
|
{
|
|
|
|
struct btrfs_transaction *cur_trans;
|
2008-07-29 22:15:18 +02:00
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
2007-04-06 21:37:36 +02:00
|
|
|
|
2008-07-29 22:15:18 +02:00
|
|
|
mutex_lock(&info->trans_mutex);
|
|
|
|
cur_trans = info->running_transaction;
|
2007-06-28 21:57:36 +02:00
|
|
|
WARN_ON(cur_trans != trans->transaction);
|
2007-03-23 15:01:08 +01:00
|
|
|
WARN_ON(cur_trans->num_writers < 1);
|
2007-06-28 21:57:36 +02:00
|
|
|
cur_trans->num_writers--;
|
2008-06-25 22:01:31 +02:00
|
|
|
|
2007-03-22 20:59:16 +01:00
|
|
|
if (waitqueue_active(&cur_trans->writer_wait))
|
|
|
|
wake_up(&cur_trans->writer_wait);
|
|
|
|
put_transaction(cur_trans);
|
2008-07-29 22:15:18 +02:00
|
|
|
mutex_unlock(&info->trans_mutex);
|
2007-03-30 20:27:56 +02:00
|
|
|
memset(trans, 0, sizeof(*trans));
|
2007-04-02 16:50:19 +02:00
|
|
|
kmem_cache_free(btrfs_trans_handle_cachep, trans);
|
2008-07-29 22:15:18 +02:00
|
|
|
|
|
|
|
if (throttle)
|
2008-07-31 16:48:37 +02:00
|
|
|
throttle_on_drops(root);
|
2008-07-29 22:15:18 +02:00
|
|
|
|
2007-03-22 20:59:16 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-06-25 22:01:31 +02:00
|
|
|
int btrfs_end_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
return __btrfs_end_transaction(trans, root, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
return __btrfs_end_transaction(trans, root, 1);
|
|
|
|
}
|
|
|
|
|
2007-03-22 20:59:16 +01:00
|
|
|
|
2008-09-11 22:17:57 +02:00
|
|
|
int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
|
|
|
|
struct extent_io_tree *dirty_pages)
|
2007-03-22 20:59:16 +01:00
|
|
|
{
|
2007-04-28 15:29:35 +02:00
|
|
|
int ret;
|
2008-08-15 21:34:15 +02:00
|
|
|
int err = 0;
|
2007-04-28 15:29:35 +02:00
|
|
|
int werr = 0;
|
|
|
|
struct page *page;
|
|
|
|
struct inode *btree_inode = root->fs_info->btree_inode;
|
2008-08-15 21:34:15 +02:00
|
|
|
u64 start = 0;
|
2007-10-15 22:14:19 +02:00
|
|
|
u64 end;
|
|
|
|
unsigned long index;
|
2007-04-28 15:29:35 +02:00
|
|
|
|
|
|
|
while(1) {
|
2008-08-15 21:34:15 +02:00
|
|
|
ret = find_first_extent_bit(dirty_pages, start, &start, &end,
|
2007-10-15 22:14:19 +02:00
|
|
|
EXTENT_DIRTY);
|
|
|
|
if (ret)
|
2007-04-28 15:29:35 +02:00
|
|
|
break;
|
2007-10-15 22:14:19 +02:00
|
|
|
while(start <= end) {
|
2008-08-15 21:34:15 +02:00
|
|
|
cond_resched();
|
|
|
|
|
2007-10-15 22:14:19 +02:00
|
|
|
index = start >> PAGE_CACHE_SHIFT;
|
2007-10-30 21:56:53 +01:00
|
|
|
start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
|
2008-09-08 17:18:08 +02:00
|
|
|
page = find_get_page(btree_inode->i_mapping, index);
|
2007-04-28 15:29:35 +02:00
|
|
|
if (!page)
|
|
|
|
continue;
|
2008-09-08 17:18:08 +02:00
|
|
|
|
|
|
|
btree_lock_page_hook(page);
|
|
|
|
if (!page->mapping) {
|
|
|
|
unlock_page(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-08-07 22:15:09 +02:00
|
|
|
if (PageWriteback(page)) {
|
|
|
|
if (PageDirty(page))
|
|
|
|
wait_on_page_writeback(page);
|
|
|
|
else {
|
|
|
|
unlock_page(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2007-04-28 15:29:35 +02:00
|
|
|
err = write_one_page(page, 0);
|
|
|
|
if (err)
|
|
|
|
werr = err;
|
|
|
|
page_cache_release(page);
|
|
|
|
}
|
|
|
|
}
|
2008-08-15 21:34:15 +02:00
|
|
|
while(1) {
|
|
|
|
ret = find_first_extent_bit(dirty_pages, 0, &start, &end,
|
|
|
|
EXTENT_DIRTY);
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
|
|
|
|
clear_extent_dirty(dirty_pages, start, end, GFP_NOFS);
|
|
|
|
while(start <= end) {
|
|
|
|
index = start >> PAGE_CACHE_SHIFT;
|
|
|
|
start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
|
|
|
|
page = find_get_page(btree_inode->i_mapping, index);
|
|
|
|
if (!page)
|
|
|
|
continue;
|
|
|
|
if (PageDirty(page)) {
|
2008-09-08 17:18:08 +02:00
|
|
|
btree_lock_page_hook(page);
|
|
|
|
wait_on_page_writeback(page);
|
2008-08-15 21:34:15 +02:00
|
|
|
err = write_one_page(page, 0);
|
|
|
|
if (err)
|
|
|
|
werr = err;
|
|
|
|
}
|
|
|
|
wait_on_page_writeback(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
}
|
2007-04-28 15:29:35 +02:00
|
|
|
if (err)
|
|
|
|
werr = err;
|
|
|
|
return werr;
|
2007-03-22 20:59:16 +01:00
|
|
|
}
|
|
|
|
|
2008-09-11 22:17:57 +02:00
|
|
|
int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
if (!trans || !trans->transaction) {
|
|
|
|
struct inode *btree_inode;
|
|
|
|
btree_inode = root->fs_info->btree_inode;
|
|
|
|
return filemap_write_and_wait(btree_inode->i_mapping);
|
|
|
|
}
|
|
|
|
return btrfs_write_and_wait_marked_extents(root,
|
|
|
|
&trans->transaction->dirty_pages);
|
|
|
|
}
|
|
|
|
|
2008-03-24 20:01:56 +01:00
|
|
|
static int update_cowonly_root(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
2007-03-22 20:59:16 +01:00
|
|
|
{
|
|
|
|
int ret;
|
2008-03-24 20:01:56 +01:00
|
|
|
u64 old_root_bytenr;
|
|
|
|
struct btrfs_root *tree_root = root->fs_info->tree_root;
|
2007-03-22 20:59:16 +01:00
|
|
|
|
2008-03-24 20:01:56 +01:00
|
|
|
btrfs_write_dirty_block_groups(trans, root);
|
2007-03-22 20:59:16 +01:00
|
|
|
while(1) {
|
2008-03-24 20:01:56 +01:00
|
|
|
old_root_bytenr = btrfs_root_bytenr(&root->root_item);
|
|
|
|
if (old_root_bytenr == root->node->start)
|
2007-03-22 20:59:16 +01:00
|
|
|
break;
|
2008-03-24 20:01:56 +01:00
|
|
|
btrfs_set_root_bytenr(&root->root_item,
|
|
|
|
root->node->start);
|
|
|
|
btrfs_set_root_level(&root->root_item,
|
|
|
|
btrfs_header_level(root->node));
|
2007-03-22 20:59:16 +01:00
|
|
|
ret = btrfs_update_root(trans, tree_root,
|
2008-03-24 20:01:56 +01:00
|
|
|
&root->root_key,
|
|
|
|
&root->root_item);
|
2007-03-22 20:59:16 +01:00
|
|
|
BUG_ON(ret);
|
2008-03-24 20:01:56 +01:00
|
|
|
btrfs_write_dirty_block_groups(trans, root);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
|
|
struct list_head *next;
|
|
|
|
|
|
|
|
while(!list_empty(&fs_info->dirty_cowonly_roots)) {
|
|
|
|
next = fs_info->dirty_cowonly_roots.next;
|
|
|
|
list_del_init(next);
|
|
|
|
root = list_entry(next, struct btrfs_root, dirty_list);
|
|
|
|
update_cowonly_root(trans, root);
|
2007-03-22 20:59:16 +01:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-05 05:23:47 +02:00
|
|
|
int btrfs_add_dead_root(struct btrfs_root *root, struct btrfs_root *latest)
|
2007-06-22 20:16:25 +02:00
|
|
|
{
|
2008-07-30 15:26:11 +02:00
|
|
|
struct btrfs_dirty_root *dirty;
|
2007-06-22 20:16:25 +02:00
|
|
|
|
|
|
|
dirty = kmalloc(sizeof(*dirty), GFP_NOFS);
|
|
|
|
if (!dirty)
|
|
|
|
return -ENOMEM;
|
|
|
|
dirty->root = root;
|
2007-09-11 17:15:39 +02:00
|
|
|
dirty->latest_root = latest;
|
2008-08-05 05:23:47 +02:00
|
|
|
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
|
|
|
list_add(&dirty->list, &latest->fs_info->dead_roots);
|
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2007-06-22 20:16:25 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-01 22:35:04 +01:00
|
|
|
static noinline int add_dirty_roots(struct btrfs_trans_handle *trans,
|
|
|
|
struct radix_tree_root *radix,
|
|
|
|
struct list_head *list)
|
2007-04-09 16:42:37 +02:00
|
|
|
{
|
2008-07-30 15:26:11 +02:00
|
|
|
struct btrfs_dirty_root *dirty;
|
2007-04-09 16:42:37 +02:00
|
|
|
struct btrfs_root *gang[8];
|
|
|
|
struct btrfs_root *root;
|
|
|
|
int i;
|
|
|
|
int ret;
|
2007-06-22 20:16:25 +02:00
|
|
|
int err = 0;
|
2007-06-22 20:16:25 +02:00
|
|
|
u32 refs;
|
2007-06-22 20:16:25 +02:00
|
|
|
|
2007-04-09 16:42:37 +02:00
|
|
|
while(1) {
|
|
|
|
ret = radix_tree_gang_lookup_tag(radix, (void **)gang, 0,
|
|
|
|
ARRAY_SIZE(gang),
|
|
|
|
BTRFS_ROOT_TRANS_TAG);
|
|
|
|
if (ret == 0)
|
|
|
|
break;
|
|
|
|
for (i = 0; i < ret; i++) {
|
|
|
|
root = gang[i];
|
2007-04-10 22:58:11 +02:00
|
|
|
radix_tree_tag_clear(radix,
|
|
|
|
(unsigned long)root->root_key.objectid,
|
|
|
|
BTRFS_ROOT_TRANS_TAG);
|
2008-07-28 21:32:19 +02:00
|
|
|
|
|
|
|
BUG_ON(!root->ref_tree);
|
2008-07-28 21:32:51 +02:00
|
|
|
dirty = root->dirty_root;
|
2008-07-28 21:32:19 +02:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
btrfs_free_log(trans, root);
|
Btrfs: update space balancing code
This patch updates the space balancing code to utilize the new
backref format. Before, btrfs-vol -b would break any COW links
on data blocks or metadata. This was slow and caused the amount
of space used to explode if a large number of snapshots were present.
The new code can keeps the sharing of all data extents and
most of the tree blocks.
To maintain the sharing of data extents, the space balance code uses
a seperate inode hold data extent pointers, then updates the references
to point to the new location.
To maintain the sharing of tree blocks, the space balance code uses
reloc trees to relocate tree blocks in reference counted roots.
There is one reloc tree for each subvol, and all reloc trees share
same root key objectid. Reloc trees are snapshots of the latest
committed roots of subvols (root->commit_root).
To relocate a tree block referenced by a subvol, there are two steps.
COW the block through subvol's reloc tree, then update block pointer in
the subvol to point to the new block. Since all reloc trees share
same root key objectid, doing special handing for tree blocks
owned by them is easy. Once a tree block has been COWed in one
reloc tree, we can use the resulting new block directly when the
same block is required to COW again through other reloc trees.
In this way, relocated tree blocks are shared between reloc trees,
so they are also shared between subvols.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-09-26 16:09:34 +02:00
|
|
|
btrfs_free_reloc_root(root);
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2007-04-09 16:42:37 +02:00
|
|
|
if (root->commit_root == root->node) {
|
2007-10-15 22:15:53 +02:00
|
|
|
WARN_ON(root->node->start !=
|
|
|
|
btrfs_root_bytenr(&root->root_item));
|
2008-07-28 21:32:19 +02:00
|
|
|
|
2007-10-15 22:14:19 +02:00
|
|
|
free_extent_buffer(root->commit_root);
|
2007-04-09 16:42:37 +02:00
|
|
|
root->commit_root = NULL;
|
2008-08-05 19:05:02 +02:00
|
|
|
root->dirty_root = NULL;
|
2008-07-30 22:29:20 +02:00
|
|
|
|
|
|
|
spin_lock(&root->list_lock);
|
|
|
|
list_del_init(&dirty->root->dead_list);
|
|
|
|
spin_unlock(&root->list_lock);
|
|
|
|
|
2008-07-28 21:32:19 +02:00
|
|
|
kfree(dirty->root);
|
|
|
|
kfree(dirty);
|
2007-08-29 21:47:34 +02:00
|
|
|
|
|
|
|
/* make sure to update the root on disk
|
|
|
|
* so we get any updates to the block used
|
|
|
|
* counts
|
|
|
|
*/
|
|
|
|
err = btrfs_update_root(trans,
|
|
|
|
root->fs_info->tree_root,
|
|
|
|
&root->root_key,
|
|
|
|
&root->root_item);
|
2007-04-09 16:42:37 +02:00
|
|
|
continue;
|
|
|
|
}
|
2007-08-07 21:52:19 +02:00
|
|
|
|
|
|
|
memset(&root->root_item.drop_progress, 0,
|
|
|
|
sizeof(struct btrfs_disk_key));
|
|
|
|
root->root_item.drop_level = 0;
|
2007-04-09 16:42:37 +02:00
|
|
|
root->commit_root = NULL;
|
2008-08-05 19:05:02 +02:00
|
|
|
root->dirty_root = NULL;
|
2007-04-09 16:42:37 +02:00
|
|
|
root->root_key.offset = root->fs_info->generation;
|
2007-10-15 22:15:53 +02:00
|
|
|
btrfs_set_root_bytenr(&root->root_item,
|
|
|
|
root->node->start);
|
|
|
|
btrfs_set_root_level(&root->root_item,
|
|
|
|
btrfs_header_level(root->node));
|
2007-04-09 16:42:37 +02:00
|
|
|
err = btrfs_insert_root(trans, root->fs_info->tree_root,
|
|
|
|
&root->root_key,
|
|
|
|
&root->root_item);
|
2007-06-22 20:16:25 +02:00
|
|
|
if (err)
|
|
|
|
break;
|
2007-08-07 21:52:19 +02:00
|
|
|
|
|
|
|
refs = btrfs_root_refs(&dirty->root->root_item);
|
|
|
|
btrfs_set_root_refs(&dirty->root->root_item, refs - 1);
|
2007-06-22 20:16:25 +02:00
|
|
|
err = btrfs_update_root(trans, root->fs_info->tree_root,
|
2007-08-07 21:52:19 +02:00
|
|
|
&dirty->root->root_key,
|
|
|
|
&dirty->root->root_item);
|
2007-06-22 20:16:25 +02:00
|
|
|
|
|
|
|
BUG_ON(err);
|
2007-08-07 21:52:19 +02:00
|
|
|
if (refs == 1) {
|
2007-06-22 20:16:25 +02:00
|
|
|
list_add(&dirty->list, list);
|
2007-08-07 21:52:19 +02:00
|
|
|
} else {
|
|
|
|
WARN_ON(1);
|
2008-07-28 21:32:19 +02:00
|
|
|
free_extent_buffer(dirty->root->node);
|
2007-08-07 21:52:19 +02:00
|
|
|
kfree(dirty->root);
|
2007-06-22 20:16:25 +02:00
|
|
|
kfree(dirty);
|
2007-08-07 21:52:19 +02:00
|
|
|
}
|
2007-04-09 16:42:37 +02:00
|
|
|
}
|
|
|
|
}
|
2007-06-22 20:16:25 +02:00
|
|
|
return err;
|
2007-04-09 16:42:37 +02:00
|
|
|
}
|
|
|
|
|
2007-08-10 20:06:19 +02:00
|
|
|
int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
|
|
|
|
{
|
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
|
|
|
int ret;
|
|
|
|
struct btrfs_trans_handle *trans;
|
2007-09-17 16:58:06 +02:00
|
|
|
unsigned long nr;
|
2007-08-10 20:06:19 +02:00
|
|
|
|
2008-06-25 22:01:30 +02:00
|
|
|
smp_mb();
|
2007-08-10 20:06:19 +02:00
|
|
|
if (root->defrag_running)
|
|
|
|
return 0;
|
|
|
|
trans = btrfs_start_transaction(root, 1);
|
2007-10-15 22:17:34 +02:00
|
|
|
while (1) {
|
2007-08-10 20:06:19 +02:00
|
|
|
root->defrag_running = 1;
|
|
|
|
ret = btrfs_defrag_leaves(trans, root, cacheonly);
|
2007-09-17 16:58:06 +02:00
|
|
|
nr = trans->blocks_used;
|
2007-08-10 20:06:19 +02:00
|
|
|
btrfs_end_transaction(trans, root);
|
2007-09-17 16:58:06 +02:00
|
|
|
btrfs_btree_balance_dirty(info->tree_root, nr);
|
2007-08-10 20:06:19 +02:00
|
|
|
cond_resched();
|
|
|
|
|
|
|
|
trans = btrfs_start_transaction(root, 1);
|
2008-06-25 22:01:31 +02:00
|
|
|
if (root->fs_info->closing || ret != -EAGAIN)
|
2007-08-10 20:06:19 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
root->defrag_running = 0;
|
2008-06-25 22:01:30 +02:00
|
|
|
smp_mb();
|
2007-08-10 20:06:19 +02:00
|
|
|
btrfs_end_transaction(trans, root);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-01 22:35:04 +01:00
|
|
|
static noinline int drop_dirty_roots(struct btrfs_root *tree_root,
|
|
|
|
struct list_head *list)
|
2007-04-09 16:42:37 +02:00
|
|
|
{
|
2008-07-30 15:26:11 +02:00
|
|
|
struct btrfs_dirty_root *dirty;
|
2007-04-09 16:42:37 +02:00
|
|
|
struct btrfs_trans_handle *trans;
|
2007-09-17 16:58:06 +02:00
|
|
|
unsigned long nr;
|
2007-10-15 22:15:53 +02:00
|
|
|
u64 num_bytes;
|
|
|
|
u64 bytes_used;
|
2008-07-30 22:29:20 +02:00
|
|
|
u64 max_useless;
|
2007-06-22 20:16:25 +02:00
|
|
|
int ret = 0;
|
2007-08-07 21:52:19 +02:00
|
|
|
int err;
|
|
|
|
|
2007-04-09 16:42:37 +02:00
|
|
|
while(!list_empty(list)) {
|
2007-08-29 21:47:34 +02:00
|
|
|
struct btrfs_root *root;
|
|
|
|
|
2008-07-30 15:26:11 +02:00
|
|
|
dirty = list_entry(list->prev, struct btrfs_dirty_root, list);
|
2007-04-09 16:42:37 +02:00
|
|
|
list_del_init(&dirty->list);
|
2007-06-22 20:16:25 +02:00
|
|
|
|
2007-10-15 22:15:53 +02:00
|
|
|
num_bytes = btrfs_root_used(&dirty->root->root_item);
|
2007-08-29 21:47:34 +02:00
|
|
|
root = dirty->latest_root;
|
2008-06-25 22:01:30 +02:00
|
|
|
atomic_inc(&root->fs_info->throttles);
|
2007-08-29 21:47:34 +02:00
|
|
|
|
2007-08-07 21:52:19 +02:00
|
|
|
while(1) {
|
|
|
|
trans = btrfs_start_transaction(tree_root, 1);
|
2008-09-26 16:05:38 +02:00
|
|
|
mutex_lock(&root->fs_info->drop_mutex);
|
2007-08-07 21:52:19 +02:00
|
|
|
ret = btrfs_drop_snapshot(trans, dirty->root);
|
|
|
|
if (ret != -EAGAIN) {
|
|
|
|
break;
|
|
|
|
}
|
2008-09-26 16:05:38 +02:00
|
|
|
mutex_unlock(&root->fs_info->drop_mutex);
|
2007-08-29 21:47:34 +02:00
|
|
|
|
2007-08-07 21:52:19 +02:00
|
|
|
err = btrfs_update_root(trans,
|
|
|
|
tree_root,
|
|
|
|
&dirty->root->root_key,
|
|
|
|
&dirty->root->root_item);
|
|
|
|
if (err)
|
|
|
|
ret = err;
|
2007-09-17 16:58:06 +02:00
|
|
|
nr = trans->blocks_used;
|
2008-07-28 21:32:51 +02:00
|
|
|
ret = btrfs_end_transaction(trans, tree_root);
|
2007-08-07 21:52:19 +02:00
|
|
|
BUG_ON(ret);
|
2008-06-25 22:01:30 +02:00
|
|
|
|
2007-09-17 16:58:06 +02:00
|
|
|
btrfs_btree_balance_dirty(tree_root, nr);
|
2007-10-15 22:18:14 +02:00
|
|
|
cond_resched();
|
2007-08-07 21:52:19 +02:00
|
|
|
}
|
2007-04-09 16:42:37 +02:00
|
|
|
BUG_ON(ret);
|
2008-06-25 22:01:30 +02:00
|
|
|
atomic_dec(&root->fs_info->throttles);
|
2008-07-28 21:32:51 +02:00
|
|
|
wake_up(&root->fs_info->transaction_throttle);
|
2007-08-29 21:47:34 +02:00
|
|
|
|
2008-06-25 22:01:30 +02:00
|
|
|
mutex_lock(&root->fs_info->alloc_mutex);
|
2007-10-15 22:15:53 +02:00
|
|
|
num_bytes -= btrfs_root_used(&dirty->root->root_item);
|
|
|
|
bytes_used = btrfs_root_used(&root->root_item);
|
|
|
|
if (num_bytes) {
|
2008-09-05 22:13:11 +02:00
|
|
|
btrfs_record_root_in_trans(root);
|
2007-10-15 22:14:19 +02:00
|
|
|
btrfs_set_root_used(&root->root_item,
|
2007-10-15 22:15:53 +02:00
|
|
|
bytes_used - num_bytes);
|
2007-08-29 21:47:34 +02:00
|
|
|
}
|
2008-06-25 22:01:30 +02:00
|
|
|
mutex_unlock(&root->fs_info->alloc_mutex);
|
|
|
|
|
2007-08-07 21:52:19 +02:00
|
|
|
ret = btrfs_del_root(trans, tree_root, &dirty->root->root_key);
|
2007-08-29 21:47:34 +02:00
|
|
|
if (ret) {
|
|
|
|
BUG();
|
2007-06-22 20:16:25 +02:00
|
|
|
break;
|
2007-08-29 21:47:34 +02:00
|
|
|
}
|
2008-06-25 22:01:30 +02:00
|
|
|
mutex_unlock(&root->fs_info->drop_mutex);
|
|
|
|
|
2008-07-30 22:29:20 +02:00
|
|
|
spin_lock(&root->list_lock);
|
|
|
|
list_del_init(&dirty->root->dead_list);
|
|
|
|
if (!list_empty(&root->dead_list)) {
|
|
|
|
struct btrfs_root *oldest;
|
|
|
|
oldest = list_entry(root->dead_list.prev,
|
|
|
|
struct btrfs_root, dead_list);
|
|
|
|
max_useless = oldest->root_key.offset - 1;
|
|
|
|
} else {
|
|
|
|
max_useless = root->root_key.offset - 1;
|
|
|
|
}
|
|
|
|
spin_unlock(&root->list_lock);
|
|
|
|
|
2007-09-17 16:58:06 +02:00
|
|
|
nr = trans->blocks_used;
|
2007-04-09 16:42:37 +02:00
|
|
|
ret = btrfs_end_transaction(trans, tree_root);
|
|
|
|
BUG_ON(ret);
|
2007-06-22 20:16:25 +02:00
|
|
|
|
2008-09-26 16:04:53 +02:00
|
|
|
ret = btrfs_remove_leaf_refs(root, max_useless, 0);
|
2008-07-30 22:29:20 +02:00
|
|
|
BUG_ON(ret);
|
|
|
|
|
2007-10-15 22:14:48 +02:00
|
|
|
free_extent_buffer(dirty->root->node);
|
2007-08-07 21:52:19 +02:00
|
|
|
kfree(dirty->root);
|
2007-04-09 16:42:37 +02:00
|
|
|
kfree(dirty);
|
2007-09-17 16:58:06 +02:00
|
|
|
|
|
|
|
btrfs_btree_balance_dirty(tree_root, nr);
|
2007-10-15 22:18:14 +02:00
|
|
|
cond_resched();
|
2007-04-09 16:42:37 +02:00
|
|
|
}
|
2007-06-22 20:16:25 +02:00
|
|
|
return ret;
|
2007-04-09 16:42:37 +02:00
|
|
|
}
|
|
|
|
|
2008-02-01 22:35:04 +01:00
|
|
|
static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
|
2008-01-08 21:46:30 +01:00
|
|
|
struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_pending_snapshot *pending)
|
|
|
|
{
|
|
|
|
struct btrfs_key key;
|
2008-02-01 22:35:04 +01:00
|
|
|
struct btrfs_root_item *new_root_item;
|
2008-01-08 21:46:30 +01:00
|
|
|
struct btrfs_root *tree_root = fs_info->tree_root;
|
|
|
|
struct btrfs_root *root = pending->root;
|
|
|
|
struct extent_buffer *tmp;
|
2008-06-25 22:01:30 +02:00
|
|
|
struct extent_buffer *old;
|
2008-01-08 21:46:30 +01:00
|
|
|
int ret;
|
2008-06-10 03:57:42 +02:00
|
|
|
int namelen;
|
2008-01-08 21:46:30 +01:00
|
|
|
u64 objectid;
|
|
|
|
|
2008-02-01 22:35:04 +01:00
|
|
|
new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
|
|
|
|
if (!new_root_item) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
2008-01-08 21:46:30 +01:00
|
|
|
ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid);
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
2008-02-01 22:35:04 +01:00
|
|
|
memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
|
2008-01-08 21:46:30 +01:00
|
|
|
|
|
|
|
key.objectid = objectid;
|
2008-09-26 16:05:38 +02:00
|
|
|
key.offset = trans->transid;
|
2008-01-08 21:46:30 +01:00
|
|
|
btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
|
|
|
|
|
2008-06-25 22:01:30 +02:00
|
|
|
old = btrfs_lock_root_node(root);
|
2008-08-01 21:11:20 +02:00
|
|
|
btrfs_cow_block(trans, root, old, NULL, 0, &old, 0);
|
2008-01-08 21:46:30 +01:00
|
|
|
|
2008-06-25 22:01:30 +02:00
|
|
|
btrfs_copy_root(trans, root, old, &tmp, objectid);
|
|
|
|
btrfs_tree_unlock(old);
|
|
|
|
free_extent_buffer(old);
|
2008-01-08 21:46:30 +01:00
|
|
|
|
2008-02-01 22:35:04 +01:00
|
|
|
btrfs_set_root_bytenr(new_root_item, tmp->start);
|
|
|
|
btrfs_set_root_level(new_root_item, btrfs_header_level(tmp));
|
2008-01-08 21:46:30 +01:00
|
|
|
ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
|
2008-02-01 22:35:04 +01:00
|
|
|
new_root_item);
|
2008-06-25 22:01:30 +02:00
|
|
|
btrfs_tree_unlock(tmp);
|
2008-01-08 21:46:30 +01:00
|
|
|
free_extent_buffer(tmp);
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* insert the directory item
|
|
|
|
*/
|
|
|
|
key.offset = (u64)-1;
|
2008-06-10 03:57:42 +02:00
|
|
|
namelen = strlen(pending->name);
|
2008-01-08 21:46:30 +01:00
|
|
|
ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
|
2008-06-10 03:57:42 +02:00
|
|
|
pending->name, namelen,
|
2008-01-08 21:46:30 +01:00
|
|
|
root->fs_info->sb->s_root->d_inode->i_ino,
|
2008-07-24 18:12:38 +02:00
|
|
|
&key, BTRFS_FT_DIR, 0);
|
2008-01-08 21:46:30 +01:00
|
|
|
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root,
|
|
|
|
pending->name, strlen(pending->name), objectid,
|
2008-07-24 18:12:38 +02:00
|
|
|
root->fs_info->sb->s_root->d_inode->i_ino, 0);
|
2008-06-10 03:57:42 +02:00
|
|
|
|
|
|
|
/* Invalidate existing dcache entry for new snapshot. */
|
|
|
|
btrfs_invalidate_dcache_root(root, pending->name, namelen);
|
|
|
|
|
2008-01-08 21:46:30 +01:00
|
|
|
fail:
|
2008-02-01 22:35:04 +01:00
|
|
|
kfree(new_root_item);
|
2008-01-08 21:46:30 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-02-01 22:35:04 +01:00
|
|
|
static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info)
|
2008-01-08 21:46:30 +01:00
|
|
|
{
|
|
|
|
struct btrfs_pending_snapshot *pending;
|
|
|
|
struct list_head *head = &trans->transaction->pending_snapshots;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
while(!list_empty(head)) {
|
|
|
|
pending = list_entry(head->next,
|
|
|
|
struct btrfs_pending_snapshot, list);
|
|
|
|
ret = create_pending_snapshot(trans, fs_info, pending);
|
|
|
|
BUG_ON(ret);
|
|
|
|
list_del(&pending->list);
|
|
|
|
kfree(pending->name);
|
|
|
|
kfree(pending);
|
|
|
|
}
|
2008-01-08 21:46:30 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-22 20:59:16 +01:00
|
|
|
int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
2007-08-10 22:22:09 +02:00
|
|
|
unsigned long joined = 0;
|
|
|
|
unsigned long timeout = 1;
|
2007-03-22 20:59:16 +01:00
|
|
|
struct btrfs_transaction *cur_trans;
|
2007-04-20 03:01:03 +02:00
|
|
|
struct btrfs_transaction *prev_trans = NULL;
|
2008-03-24 20:01:56 +01:00
|
|
|
struct btrfs_root *chunk_root = root->fs_info->chunk_root;
|
2007-04-09 16:42:37 +02:00
|
|
|
struct list_head dirty_fs_roots;
|
2008-01-24 22:13:08 +01:00
|
|
|
struct extent_io_tree *pinned_copy;
|
2007-03-22 20:59:16 +01:00
|
|
|
DEFINE_WAIT(wait);
|
2007-08-10 22:22:09 +02:00
|
|
|
int ret;
|
2007-03-22 20:59:16 +01:00
|
|
|
|
2007-04-09 16:42:37 +02:00
|
|
|
INIT_LIST_HEAD(&dirty_fs_roots);
|
2007-03-22 20:59:16 +01:00
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
|
|
|
if (trans->transaction->in_commit) {
|
|
|
|
cur_trans = trans->transaction;
|
|
|
|
trans->transaction->use_count++;
|
2007-06-28 21:57:36 +02:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2007-03-22 20:59:16 +01:00
|
|
|
btrfs_end_transaction(trans, root);
|
2007-06-28 21:57:36 +02:00
|
|
|
|
2007-03-22 20:59:16 +01:00
|
|
|
ret = wait_for_commit(root, cur_trans);
|
|
|
|
BUG_ON(ret);
|
2007-08-10 22:22:09 +02:00
|
|
|
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
2007-03-22 20:59:16 +01:00
|
|
|
put_transaction(cur_trans);
|
2007-08-10 22:22:09 +02:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
|
|
|
|
2007-03-22 20:59:16 +01:00
|
|
|
return 0;
|
|
|
|
}
|
2008-01-03 15:08:48 +01:00
|
|
|
|
|
|
|
pinned_copy = kmalloc(sizeof(*pinned_copy), GFP_NOFS);
|
|
|
|
if (!pinned_copy)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
extent_io_tree_init(pinned_copy,
|
2008-01-03 15:08:48 +01:00
|
|
|
root->fs_info->btree_inode->i_mapping, GFP_NOFS);
|
|
|
|
|
2007-04-02 16:50:19 +02:00
|
|
|
trans->transaction->in_commit = 1;
|
2008-07-17 18:54:14 +02:00
|
|
|
trans->transaction->blocked = 1;
|
2007-06-28 21:57:36 +02:00
|
|
|
cur_trans = trans->transaction;
|
|
|
|
if (cur_trans->list.prev != &root->fs_info->trans_list) {
|
|
|
|
prev_trans = list_entry(cur_trans->list.prev,
|
|
|
|
struct btrfs_transaction, list);
|
|
|
|
if (!prev_trans->commit_done) {
|
|
|
|
prev_trans->use_count++;
|
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
|
|
|
|
|
|
|
wait_for_commit(root, prev_trans);
|
|
|
|
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
2007-08-10 22:22:09 +02:00
|
|
|
put_transaction(prev_trans);
|
2007-06-28 21:57:36 +02:00
|
|
|
}
|
|
|
|
}
|
2007-08-10 22:22:09 +02:00
|
|
|
|
|
|
|
do {
|
2008-08-05 19:05:02 +02:00
|
|
|
int snap_pending = 0;
|
2007-08-10 22:22:09 +02:00
|
|
|
joined = cur_trans->num_joined;
|
2008-08-05 19:05:02 +02:00
|
|
|
if (!list_empty(&trans->transaction->pending_snapshots))
|
|
|
|
snap_pending = 1;
|
|
|
|
|
2007-04-02 16:50:19 +02:00
|
|
|
WARN_ON(cur_trans != trans->transaction);
|
2007-08-10 22:22:09 +02:00
|
|
|
prepare_to_wait(&cur_trans->writer_wait, &wait,
|
2007-03-22 20:59:16 +01:00
|
|
|
TASK_UNINTERRUPTIBLE);
|
2007-08-10 22:22:09 +02:00
|
|
|
|
|
|
|
if (cur_trans->num_writers > 1)
|
|
|
|
timeout = MAX_SCHEDULE_TIMEOUT;
|
|
|
|
else
|
|
|
|
timeout = 1;
|
|
|
|
|
2007-03-22 20:59:16 +01:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2007-08-10 22:22:09 +02:00
|
|
|
|
2008-08-05 19:05:02 +02:00
|
|
|
if (snap_pending) {
|
|
|
|
ret = btrfs_wait_ordered_extents(root, 1);
|
|
|
|
BUG_ON(ret);
|
|
|
|
}
|
|
|
|
|
2007-08-10 22:22:09 +02:00
|
|
|
schedule_timeout(timeout);
|
|
|
|
|
2007-03-22 20:59:16 +01:00
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
2007-08-10 22:22:09 +02:00
|
|
|
finish_wait(&cur_trans->writer_wait, &wait);
|
|
|
|
} while (cur_trans->num_writers > 1 ||
|
|
|
|
(cur_trans->num_joined != joined));
|
|
|
|
|
2008-01-08 21:46:30 +01:00
|
|
|
ret = create_pending_snapshots(trans, root->fs_info);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
2007-04-02 16:50:19 +02:00
|
|
|
WARN_ON(cur_trans != trans->transaction);
|
2008-01-08 21:46:30 +01:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
/* btrfs_commit_tree_roots is responsible for getting the
|
|
|
|
* various roots consistent with each other. Every pointer
|
|
|
|
* in the tree of tree roots has to point to the most up to date
|
|
|
|
* root for every subvolume and other tree. So, we have to keep
|
|
|
|
* the tree logging code from jumping in and changing any
|
|
|
|
* of the trees.
|
|
|
|
*
|
|
|
|
* At this point in the commit, there can't be any tree-log
|
|
|
|
* writers, but a little lower down we drop the trans mutex
|
|
|
|
* and let new people in. By holding the tree_log_mutex
|
|
|
|
* from now until after the super is written, we avoid races
|
|
|
|
* with the tree-log code.
|
|
|
|
*/
|
|
|
|
mutex_lock(&root->fs_info->tree_log_mutex);
|
Btrfs: update space balancing code
This patch updates the space balancing code to utilize the new
backref format. Before, btrfs-vol -b would break any COW links
on data blocks or metadata. This was slow and caused the amount
of space used to explode if a large number of snapshots were present.
The new code can keeps the sharing of all data extents and
most of the tree blocks.
To maintain the sharing of data extents, the space balance code uses
a seperate inode hold data extent pointers, then updates the references
to point to the new location.
To maintain the sharing of tree blocks, the space balance code uses
reloc trees to relocate tree blocks in reference counted roots.
There is one reloc tree for each subvol, and all reloc trees share
same root key objectid. Reloc trees are snapshots of the latest
committed roots of subvols (root->commit_root).
To relocate a tree block referenced by a subvol, there are two steps.
COW the block through subvol's reloc tree, then update block pointer in
the subvol to point to the new block. Since all reloc trees share
same root key objectid, doing special handing for tree blocks
owned by them is easy. Once a tree block has been COWed in one
reloc tree, we can use the resulting new block directly when the
same block is required to COW again through other reloc trees.
In this way, relocated tree blocks are shared between reloc trees,
so they are also shared between subvols.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-09-26 16:09:34 +02:00
|
|
|
/*
|
|
|
|
* keep tree reloc code from adding new reloc trees
|
|
|
|
*/
|
|
|
|
mutex_lock(&root->fs_info->tree_reloc_mutex);
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
|
2007-06-22 20:16:25 +02:00
|
|
|
ret = add_dirty_roots(trans, &root->fs_info->fs_roots_radix,
|
|
|
|
&dirty_fs_roots);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
/* add_dirty_roots gets rid of all the tree log roots, it is now
|
|
|
|
* safe to free the root of tree log roots
|
|
|
|
*/
|
|
|
|
btrfs_free_log_root_tree(trans, root->fs_info);
|
|
|
|
|
Btrfs: update space balancing code
This patch updates the space balancing code to utilize the new
backref format. Before, btrfs-vol -b would break any COW links
on data blocks or metadata. This was slow and caused the amount
of space used to explode if a large number of snapshots were present.
The new code can keeps the sharing of all data extents and
most of the tree blocks.
To maintain the sharing of data extents, the space balance code uses
a seperate inode hold data extent pointers, then updates the references
to point to the new location.
To maintain the sharing of tree blocks, the space balance code uses
reloc trees to relocate tree blocks in reference counted roots.
There is one reloc tree for each subvol, and all reloc trees share
same root key objectid. Reloc trees are snapshots of the latest
committed roots of subvols (root->commit_root).
To relocate a tree block referenced by a subvol, there are two steps.
COW the block through subvol's reloc tree, then update block pointer in
the subvol to point to the new block. Since all reloc trees share
same root key objectid, doing special handing for tree blocks
owned by them is easy. Once a tree block has been COWed in one
reloc tree, we can use the resulting new block directly when the
same block is required to COW again through other reloc trees.
In this way, relocated tree blocks are shared between reloc trees,
so they are also shared between subvols.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-09-26 16:09:34 +02:00
|
|
|
btrfs_free_reloc_mappings(root);
|
|
|
|
|
2007-03-22 20:59:16 +01:00
|
|
|
ret = btrfs_commit_tree_roots(trans, root);
|
|
|
|
BUG_ON(ret);
|
2007-06-22 20:16:25 +02:00
|
|
|
|
2007-03-25 17:35:08 +02:00
|
|
|
cur_trans = root->fs_info->running_transaction;
|
2008-01-15 14:40:48 +01:00
|
|
|
spin_lock(&root->fs_info->new_trans_lock);
|
2007-03-25 17:35:08 +02:00
|
|
|
root->fs_info->running_transaction = NULL;
|
2008-01-15 14:40:48 +01:00
|
|
|
spin_unlock(&root->fs_info->new_trans_lock);
|
2007-06-26 16:06:50 +02:00
|
|
|
btrfs_set_super_generation(&root->fs_info->super_copy,
|
|
|
|
cur_trans->transid);
|
|
|
|
btrfs_set_super_root(&root->fs_info->super_copy,
|
2007-10-15 22:15:53 +02:00
|
|
|
root->fs_info->tree_root->node->start);
|
|
|
|
btrfs_set_super_root_level(&root->fs_info->super_copy,
|
|
|
|
btrfs_header_level(root->fs_info->tree_root->node));
|
2007-10-15 22:14:19 +02:00
|
|
|
|
2008-03-24 20:01:56 +01:00
|
|
|
btrfs_set_super_chunk_root(&root->fs_info->super_copy,
|
|
|
|
chunk_root->node->start);
|
|
|
|
btrfs_set_super_chunk_root_level(&root->fs_info->super_copy,
|
|
|
|
btrfs_header_level(chunk_root->node));
|
2008-09-05 22:13:11 +02:00
|
|
|
|
|
|
|
if (!root->fs_info->log_root_recovering) {
|
|
|
|
btrfs_set_super_log_root(&root->fs_info->super_copy, 0);
|
|
|
|
btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0);
|
|
|
|
}
|
|
|
|
|
2008-05-07 17:43:44 +02:00
|
|
|
memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
|
|
|
|
sizeof(root->fs_info->super_copy));
|
2007-06-28 21:57:36 +02:00
|
|
|
|
2008-01-03 15:08:48 +01:00
|
|
|
btrfs_copy_pinned(root, pinned_copy);
|
2007-06-28 21:57:36 +02:00
|
|
|
|
2008-07-17 18:54:14 +02:00
|
|
|
trans->transaction->blocked = 0;
|
2008-07-17 18:53:50 +02:00
|
|
|
wake_up(&root->fs_info->transaction_throttle);
|
2008-07-17 18:54:14 +02:00
|
|
|
wake_up(&root->fs_info->transaction_wait);
|
2008-07-17 18:53:50 +02:00
|
|
|
|
2007-03-25 17:35:08 +02:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2007-03-22 20:59:16 +01:00
|
|
|
ret = btrfs_write_and_wait_transaction(trans, root);
|
|
|
|
BUG_ON(ret);
|
|
|
|
write_ctree_super(trans, root);
|
2008-01-03 15:08:48 +01:00
|
|
|
|
2008-09-05 22:13:11 +02:00
|
|
|
/*
|
|
|
|
* the super is written, we can safely allow the tree-loggers
|
|
|
|
* to go about their business
|
|
|
|
*/
|
|
|
|
mutex_unlock(&root->fs_info->tree_log_mutex);
|
|
|
|
|
2008-01-03 15:08:48 +01:00
|
|
|
btrfs_finish_extent_commit(trans, root, pinned_copy);
|
|
|
|
kfree(pinned_copy);
|
|
|
|
|
Btrfs: update space balancing code
This patch updates the space balancing code to utilize the new
backref format. Before, btrfs-vol -b would break any COW links
on data blocks or metadata. This was slow and caused the amount
of space used to explode if a large number of snapshots were present.
The new code can keeps the sharing of all data extents and
most of the tree blocks.
To maintain the sharing of data extents, the space balance code uses
a seperate inode hold data extent pointers, then updates the references
to point to the new location.
To maintain the sharing of tree blocks, the space balance code uses
reloc trees to relocate tree blocks in reference counted roots.
There is one reloc tree for each subvol, and all reloc trees share
same root key objectid. Reloc trees are snapshots of the latest
committed roots of subvols (root->commit_root).
To relocate a tree block referenced by a subvol, there are two steps.
COW the block through subvol's reloc tree, then update block pointer in
the subvol to point to the new block. Since all reloc trees share
same root key objectid, doing special handing for tree blocks
owned by them is easy. Once a tree block has been COWed in one
reloc tree, we can use the resulting new block directly when the
same block is required to COW again through other reloc trees.
In this way, relocated tree blocks are shared between reloc trees,
so they are also shared between subvols.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-09-26 16:09:34 +02:00
|
|
|
btrfs_drop_dead_reloc_roots(root);
|
|
|
|
mutex_unlock(&root->fs_info->tree_reloc_mutex);
|
|
|
|
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
|
|
|
|
2007-04-02 16:50:19 +02:00
|
|
|
cur_trans->commit_done = 1;
|
2007-08-10 22:22:09 +02:00
|
|
|
root->fs_info->last_trans_committed = cur_trans->transid;
|
2007-04-02 16:50:19 +02:00
|
|
|
wake_up(&cur_trans->commit_wait);
|
2007-03-25 17:35:08 +02:00
|
|
|
put_transaction(cur_trans);
|
2007-03-22 20:59:16 +01:00
|
|
|
put_transaction(cur_trans);
|
2007-08-29 21:47:34 +02:00
|
|
|
|
2008-07-30 22:29:20 +02:00
|
|
|
list_splice_init(&dirty_fs_roots, &root->fs_info->dead_roots);
|
2007-06-09 00:11:48 +02:00
|
|
|
if (root->fs_info->closing)
|
|
|
|
list_splice_init(&root->fs_info->dead_roots, &dirty_fs_roots);
|
2007-08-29 21:47:34 +02:00
|
|
|
|
2007-03-25 17:35:08 +02:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2007-04-02 16:50:19 +02:00
|
|
|
kmem_cache_free(btrfs_trans_handle_cachep, trans);
|
2007-03-22 20:59:16 +01:00
|
|
|
|
2007-06-09 00:11:48 +02:00
|
|
|
if (root->fs_info->closing) {
|
|
|
|
drop_dirty_roots(root->fs_info->tree_root, &dirty_fs_roots);
|
|
|
|
}
|
2007-03-22 20:59:16 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-08-10 20:06:19 +02:00
|
|
|
int btrfs_clean_old_snapshots(struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
struct list_head dirty_roots;
|
|
|
|
INIT_LIST_HEAD(&dirty_roots);
|
2008-06-25 22:01:31 +02:00
|
|
|
again:
|
2007-08-10 20:06:19 +02:00
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
|
|
|
list_splice_init(&root->fs_info->dead_roots, &dirty_roots);
|
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
|
|
|
|
|
|
|
if (!list_empty(&dirty_roots)) {
|
|
|
|
drop_dirty_roots(root, &dirty_roots);
|
2008-06-25 22:01:31 +02:00
|
|
|
goto again;
|
2007-08-10 20:06:19 +02:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|