2007-06-12 13:07:21 +00: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 19:59:16 +00:00
|
|
|
#include <linux/fs.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2007-06-12 15:36:58 +00:00
|
|
|
#include <linux/sched.h>
|
2007-09-17 14:58:06 +00:00
|
|
|
#include <linux/writeback.h>
|
2007-10-15 20:14:19 +00:00
|
|
|
#include <linux/pagemap.h>
|
2008-11-07 23:22:45 +00:00
|
|
|
#include <linux/blkdev.h>
|
2007-03-22 19:59:16 +00:00
|
|
|
#include "ctree.h"
|
|
|
|
#include "disk-io.h"
|
|
|
|
#include "transaction.h"
|
2008-06-25 20:01:30 +00:00
|
|
|
#include "locking.h"
|
2008-09-05 20:13:11 +00:00
|
|
|
#include "tree-log.h"
|
2007-03-22 19:59:16 +00:00
|
|
|
|
2007-04-09 14:42:37 +00:00
|
|
|
#define BTRFS_ROOT_TRANS_TAG 0
|
|
|
|
|
2008-02-01 21:35:04 +00:00
|
|
|
static noinline void put_transaction(struct btrfs_transaction *transaction)
|
2007-03-22 19:59:16 +00:00
|
|
|
{
|
2007-04-02 14:50:19 +00:00
|
|
|
WARN_ON(transaction->use_count == 0);
|
2007-03-22 19:59:16 +00:00
|
|
|
transaction->use_count--;
|
2007-03-25 15:35:08 +00:00
|
|
|
if (transaction->use_count == 0) {
|
2007-04-20 01:01:03 +00:00
|
|
|
list_del_init(&transaction->list);
|
2007-04-02 14:50:19 +00:00
|
|
|
memset(transaction, 0, sizeof(*transaction));
|
|
|
|
kmem_cache_free(btrfs_transaction_cachep, transaction);
|
2007-03-25 15:35:08 +00:00
|
|
|
}
|
2007-03-22 19:59:16 +00:00
|
|
|
}
|
|
|
|
|
Btrfs: async block group caching
This patch moves the caching of the block group off to a kthread in order to
allow people to allocate sooner. Instead of blocking up behind the caching
mutex, we instead kick of the caching kthread, and then attempt to make an
allocation. If we cannot, we wait on the block groups caching waitqueue, which
the caching kthread will wake the waiting threads up everytime it finds 2 meg
worth of space, and then again when its finished caching. This is how I tested
the speedup from this
mkfs the disk
mount the disk
fill the disk up with fs_mark
unmount the disk
mount the disk
time touch /mnt/foo
Without my changes this took 11 seconds on my box, with these changes it now
takes 1 second.
Another change thats been put in place is we lock the super mirror's in the
pinned extent map in order to keep us from adding that stuff as free space when
caching the block group. This doesn't really change anything else as far as the
pinned extent map is concerned, since for actual pinned extents we use
EXTENT_DIRTY, but it does mean that when we unmount we have to go in and unlock
those extents to keep from leaking memory.
I've also added a check where when we are reading block groups from disk, if the
amount of space used == the size of the block group, we go ahead and mark the
block group as cached. This drastically reduces the amount of time it takes to
cache the block groups. Using the same test as above, except doing a dd to a
file and then unmounting, it used to take 33 seconds to umount, now it takes 3
seconds.
This version uses the commit_root in the caching kthread, and then keeps track
of how many async caching threads are running at any given time so if one of the
async threads is still running as we cross transactions we can wait until its
finished before handling the pinned extents. Thank you,
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-07-14 01:29:25 +00:00
|
|
|
static noinline void switch_commit_root(struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
free_extent_buffer(root->commit_root);
|
|
|
|
root->commit_root = btrfs_root_node(root);
|
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
|
|
|
* either allocate a new transaction or hop into the existing one
|
|
|
|
*/
|
2008-02-01 21:35:04 +00:00
|
|
|
static noinline int join_transaction(struct btrfs_root *root)
|
2007-03-22 19:59:16 +00:00
|
|
|
{
|
|
|
|
struct btrfs_transaction *cur_trans;
|
|
|
|
cur_trans = root->fs_info->running_transaction;
|
|
|
|
if (!cur_trans) {
|
2007-04-02 14:50:19 +00:00
|
|
|
cur_trans = kmem_cache_alloc(btrfs_transaction_cachep,
|
|
|
|
GFP_NOFS);
|
2007-03-22 19:59:16 +00:00
|
|
|
BUG_ON(!cur_trans);
|
2007-04-09 14:42:37 +00:00
|
|
|
root->fs_info->generation++;
|
2007-08-10 20:22:09 +00:00
|
|
|
cur_trans->num_writers = 1;
|
|
|
|
cur_trans->num_joined = 0;
|
2007-04-09 14:42:37 +00:00
|
|
|
cur_trans->transid = root->fs_info->generation;
|
2007-03-22 19:59:16 +00:00
|
|
|
init_waitqueue_head(&cur_trans->writer_wait);
|
|
|
|
init_waitqueue_head(&cur_trans->commit_wait);
|
|
|
|
cur_trans->in_commit = 0;
|
2008-07-17 16:54:14 +00:00
|
|
|
cur_trans->blocked = 0;
|
2007-03-23 14:01:08 +00:00
|
|
|
cur_trans->use_count = 1;
|
2007-03-22 19:59:16 +00:00
|
|
|
cur_trans->commit_done = 0;
|
2007-06-08 19:33:54 +00:00
|
|
|
cur_trans->start_time = get_seconds();
|
2009-03-13 14:10:06 +00:00
|
|
|
|
2010-02-23 19:43:04 +00:00
|
|
|
cur_trans->delayed_refs.root = RB_ROOT;
|
2009-03-13 14:10:06 +00:00
|
|
|
cur_trans->delayed_refs.num_entries = 0;
|
2009-03-13 14:17:05 +00:00
|
|
|
cur_trans->delayed_refs.num_heads_ready = 0;
|
|
|
|
cur_trans->delayed_refs.num_heads = 0;
|
2009-03-13 14:10:06 +00:00
|
|
|
cur_trans->delayed_refs.flushing = 0;
|
2009-03-13 14:17:05 +00:00
|
|
|
cur_trans->delayed_refs.run_delayed_start = 0;
|
2009-03-13 14:10:06 +00:00
|
|
|
spin_lock_init(&cur_trans->delayed_refs.lock);
|
|
|
|
|
2008-01-08 20:46:30 +00:00
|
|
|
INIT_LIST_HEAD(&cur_trans->pending_snapshots);
|
2007-04-20 01:01:03 +00:00
|
|
|
list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
|
2008-01-24 21:13:08 +00:00
|
|
|
extent_io_tree_init(&cur_trans->dirty_pages,
|
2007-10-15 20:14:19 +00:00
|
|
|
root->fs_info->btree_inode->i_mapping,
|
|
|
|
GFP_NOFS);
|
2008-06-09 13:35:50 +00: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 20:22:09 +00:00
|
|
|
} else {
|
|
|
|
cur_trans->num_writers++;
|
|
|
|
cur_trans->num_joined++;
|
2007-03-22 19:59:16 +00:00
|
|
|
}
|
2007-08-10 20:22:09 +00:00
|
|
|
|
2007-03-22 19:59:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
2009-01-06 02:25:51 +00:00
|
|
|
* this does all the record keeping required to make sure that a reference
|
|
|
|
* counted root is properly recorded in a given transaction. This is required
|
|
|
|
* to make sure the old root from before we joined the transaction is deleted
|
|
|
|
* when the transaction commits
|
2008-09-29 19:18:18 +00:00
|
|
|
*/
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
static noinline int record_root_in_trans(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
2007-08-07 20:15:09 +00:00
|
|
|
{
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
if (root->ref_cows && root->last_trans < trans->transid) {
|
2007-08-07 20:15:09 +00:00
|
|
|
WARN_ON(root == root->fs_info->extent_root);
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
WARN_ON(root->commit_root != root->node);
|
|
|
|
|
|
|
|
radix_tree_tag_set(&root->fs_info->fs_roots_radix,
|
|
|
|
(unsigned long)root->root_key.objectid,
|
|
|
|
BTRFS_ROOT_TRANS_TAG);
|
|
|
|
root->last_trans = trans->transid;
|
|
|
|
btrfs_init_reloc_root(trans, root);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2008-07-30 20:29:20 +00:00
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
if (!root->ref_cows)
|
|
|
|
return 0;
|
2008-07-30 20:29:20 +00:00
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
|
|
|
if (root->last_trans == trans->transid) {
|
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
|
|
|
return 0;
|
2007-08-07 20:15:09 +00:00
|
|
|
}
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
|
|
|
|
record_root_in_trans(trans, root);
|
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2007-08-07 20:15:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/* wait for commit against the current transaction to become unblocked
|
|
|
|
* when this is done, it is safe to start a new transaction, but the current
|
|
|
|
* transaction might not be fully on disk.
|
|
|
|
*/
|
2008-07-31 14:48:37 +00:00
|
|
|
static void wait_current_trans(struct btrfs_root *root)
|
2007-03-22 19:59:16 +00:00
|
|
|
{
|
2008-07-17 16:54:14 +00:00
|
|
|
struct btrfs_transaction *cur_trans;
|
2007-03-22 19:59:16 +00:00
|
|
|
|
2008-07-17 16:54:14 +00:00
|
|
|
cur_trans = root->fs_info->running_transaction;
|
2008-07-31 14:48:37 +00:00
|
|
|
if (cur_trans && cur_trans->blocked) {
|
2008-07-17 16:54:14 +00:00
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
cur_trans->use_count++;
|
2009-01-06 02:25:51 +00:00
|
|
|
while (1) {
|
2008-07-17 16:54:14 +00:00
|
|
|
prepare_to_wait(&root->fs_info->transaction_wait, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
2010-03-25 12:35:14 +00:00
|
|
|
if (!cur_trans->blocked)
|
2008-07-17 16:54:14 +00:00
|
|
|
break;
|
2010-03-25 12:35:14 +00:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
|
|
|
schedule();
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
2008-07-17 16:54:14 +00:00
|
|
|
}
|
2010-03-25 12:35:14 +00:00
|
|
|
finish_wait(&root->fs_info->transaction_wait, &wait);
|
2008-07-17 16:54:14 +00:00
|
|
|
put_transaction(cur_trans);
|
|
|
|
}
|
2008-07-31 14:48:37 +00:00
|
|
|
}
|
|
|
|
|
2009-11-11 02:23:48 +00:00
|
|
|
enum btrfs_trans_type {
|
|
|
|
TRANS_START,
|
|
|
|
TRANS_JOIN,
|
|
|
|
TRANS_USERSPACE,
|
2010-06-21 18:48:16 +00:00
|
|
|
TRANS_JOIN_NOLOCK,
|
2009-11-11 02:23:48 +00:00
|
|
|
};
|
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
static int may_wait_transaction(struct btrfs_root *root, int type)
|
|
|
|
{
|
|
|
|
if (!root->fs_info->log_root_recovering &&
|
|
|
|
((type == TRANS_START && !root->fs_info->open_ioctl_trans) ||
|
|
|
|
type == TRANS_USERSPACE))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-05 20:13:11 +00:00
|
|
|
static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
|
2010-05-16 14:48:46 +00:00
|
|
|
u64 num_items, int type)
|
2008-07-31 14:48:37 +00:00
|
|
|
{
|
2010-05-16 14:48:46 +00:00
|
|
|
struct btrfs_trans_handle *h;
|
|
|
|
struct btrfs_transaction *cur_trans;
|
|
|
|
int retries = 0;
|
2008-07-31 14:48:37 +00:00
|
|
|
int ret;
|
2010-05-16 14:48:46 +00:00
|
|
|
again:
|
|
|
|
h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
|
|
|
|
if (!h)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2008-07-31 14:48:37 +00:00
|
|
|
|
2010-06-21 18:48:16 +00:00
|
|
|
if (type != TRANS_JOIN_NOLOCK)
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
2010-05-16 14:48:46 +00:00
|
|
|
if (may_wait_transaction(root, type))
|
2008-07-31 14:48:37 +00:00
|
|
|
wait_current_trans(root);
|
2010-05-16 14:48:46 +00:00
|
|
|
|
2007-03-22 19:59:16 +00:00
|
|
|
ret = join_transaction(root);
|
|
|
|
BUG_ON(ret);
|
2007-04-09 14:42:37 +00:00
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
cur_trans = root->fs_info->running_transaction;
|
|
|
|
cur_trans->use_count++;
|
2010-06-21 18:48:16 +00:00
|
|
|
if (type != TRANS_JOIN_NOLOCK)
|
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2010-05-16 14:48:46 +00:00
|
|
|
|
|
|
|
h->transid = cur_trans->transid;
|
|
|
|
h->transaction = cur_trans;
|
2007-03-22 19:59:16 +00:00
|
|
|
h->blocks_used = 0;
|
2008-12-11 21:30:39 +00:00
|
|
|
h->block_group = 0;
|
2010-05-16 14:48:46 +00:00
|
|
|
h->bytes_reserved = 0;
|
2009-03-13 14:10:06 +00:00
|
|
|
h->delayed_ref_updates = 0;
|
2010-05-16 14:46:25 +00:00
|
|
|
h->block_rsv = NULL;
|
2009-03-13 00:12:45 +00:00
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
smp_mb();
|
|
|
|
if (cur_trans->blocked && may_wait_transaction(root, type)) {
|
|
|
|
btrfs_commit_transaction(h, root);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (num_items > 0) {
|
|
|
|
ret = btrfs_trans_reserve_metadata(h, root, num_items,
|
|
|
|
&retries);
|
|
|
|
if (ret == -EAGAIN) {
|
|
|
|
btrfs_commit_transaction(h, root);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
if (ret < 0) {
|
|
|
|
btrfs_end_transaction(h, root);
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
|
|
|
}
|
2009-09-11 20:12:44 +00:00
|
|
|
|
2010-06-21 18:48:16 +00:00
|
|
|
if (type != TRANS_JOIN_NOLOCK)
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
record_root_in_trans(h, root);
|
2010-06-21 18:48:16 +00:00
|
|
|
if (type != TRANS_JOIN_NOLOCK)
|
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2010-05-16 14:48:46 +00:00
|
|
|
|
|
|
|
if (!current->journal_info && type != TRANS_USERSPACE)
|
|
|
|
current->journal_info = h;
|
2007-03-22 19:59:16 +00:00
|
|
|
return h;
|
|
|
|
}
|
|
|
|
|
2008-07-17 16:54:14 +00:00
|
|
|
struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
|
2010-05-16 14:48:46 +00:00
|
|
|
int num_items)
|
2008-07-17 16:54:14 +00:00
|
|
|
{
|
2010-05-16 14:48:46 +00:00
|
|
|
return start_transaction(root, num_items, TRANS_START);
|
2008-07-17 16:54:14 +00:00
|
|
|
}
|
|
|
|
struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root,
|
|
|
|
int num_blocks)
|
|
|
|
{
|
2010-05-16 14:48:46 +00:00
|
|
|
return start_transaction(root, 0, TRANS_JOIN);
|
2008-07-17 16:54:14 +00:00
|
|
|
}
|
|
|
|
|
2010-06-21 18:48:16 +00:00
|
|
|
struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root,
|
|
|
|
int num_blocks)
|
|
|
|
{
|
|
|
|
return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
|
|
|
|
}
|
|
|
|
|
2008-08-04 14:41:27 +00:00
|
|
|
struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r,
|
|
|
|
int num_blocks)
|
|
|
|
{
|
2010-05-16 14:48:46 +00:00
|
|
|
return start_transaction(r, 0, TRANS_USERSPACE);
|
2008-08-04 14:41:27 +00:00
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/* wait for a transaction commit to be fully complete */
|
2008-06-25 20:01:31 +00: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);
|
2009-01-06 02:25:51 +00:00
|
|
|
while (!commit->commit_done) {
|
2008-06-25 20:01:31 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
#if 0
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
2009-01-06 02:25:51 +00:00
|
|
|
* rate limit against the drop_snapshot code. This helps to slow down new
|
|
|
|
* operations if the drop_snapshot code isn't able to keep up.
|
2008-09-29 19:18:18 +00:00
|
|
|
*/
|
2008-07-31 14:48:37 +00:00
|
|
|
static void throttle_on_drops(struct btrfs_root *root)
|
2008-07-29 20:15:18 +00:00
|
|
|
{
|
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
2008-08-04 12:20:15 +00:00
|
|
|
int harder_count = 0;
|
2008-07-29 20:15:18 +00:00
|
|
|
|
2008-08-04 12:20:15 +00:00
|
|
|
harder:
|
2008-07-29 20:15:18 +00: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 12:20:15 +00: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 20:15:18 +00:00
|
|
|
}
|
|
|
|
}
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
#endif
|
2008-07-29 20:15:18 +00:00
|
|
|
|
2008-07-31 14:48:37 +00:00
|
|
|
void btrfs_throttle(struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
2008-08-04 14:41:27 +00:00
|
|
|
if (!root->fs_info->open_ioctl_trans)
|
|
|
|
wait_current_trans(root);
|
2008-07-31 14:48:37 +00:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
|
|
|
}
|
|
|
|
|
2010-05-16 14:49:58 +00:00
|
|
|
static int should_end_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
ret = btrfs_block_rsv_check(trans, root,
|
|
|
|
&root->fs_info->global_block_rsv, 0, 5);
|
|
|
|
return ret ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
struct btrfs_transaction *cur_trans = trans->transaction;
|
|
|
|
int updates;
|
|
|
|
|
|
|
|
if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
updates = trans->delayed_ref_updates;
|
|
|
|
trans->delayed_ref_updates = 0;
|
|
|
|
if (updates)
|
|
|
|
btrfs_run_delayed_refs(trans, root, updates);
|
|
|
|
|
|
|
|
return should_end_transaction(trans, root);
|
|
|
|
}
|
|
|
|
|
2008-06-25 20:01:31 +00:00
|
|
|
static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
|
2010-06-21 18:48:16 +00:00
|
|
|
struct btrfs_root *root, int throttle, int lock)
|
2007-03-22 19:59:16 +00:00
|
|
|
{
|
2010-05-16 14:49:58 +00:00
|
|
|
struct btrfs_transaction *cur_trans = trans->transaction;
|
2008-07-29 20:15:18 +00:00
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
2009-03-13 14:17:05 +00:00
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
while (count < 4) {
|
|
|
|
unsigned long cur = trans->delayed_ref_updates;
|
|
|
|
trans->delayed_ref_updates = 0;
|
|
|
|
if (cur &&
|
|
|
|
trans->transaction->delayed_refs.num_heads_ready > 64) {
|
|
|
|
trans->delayed_ref_updates = 0;
|
2009-03-13 00:12:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* do a full flush if the transaction is trying
|
|
|
|
* to close
|
|
|
|
*/
|
|
|
|
if (trans->transaction->delayed_refs.flushing)
|
|
|
|
cur = 0;
|
2009-03-13 14:17:05 +00:00
|
|
|
btrfs_run_delayed_refs(trans, root, cur);
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
count++;
|
2009-03-13 14:10:06 +00:00
|
|
|
}
|
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
btrfs_trans_release_metadata(trans, root);
|
|
|
|
|
2010-06-21 18:48:16 +00:00
|
|
|
if (lock && !root->fs_info->open_ioctl_trans &&
|
2010-05-16 14:49:58 +00:00
|
|
|
should_end_transaction(trans, root))
|
|
|
|
trans->transaction->blocked = 1;
|
|
|
|
|
2010-06-21 18:48:16 +00:00
|
|
|
if (lock && cur_trans->blocked && !cur_trans->in_commit) {
|
2010-05-16 14:49:58 +00:00
|
|
|
if (throttle)
|
|
|
|
return btrfs_commit_transaction(trans, root);
|
|
|
|
else
|
|
|
|
wake_up_process(info->transaction_kthread);
|
|
|
|
}
|
|
|
|
|
2010-06-21 18:48:16 +00:00
|
|
|
if (lock)
|
|
|
|
mutex_lock(&info->trans_mutex);
|
2010-05-16 14:49:58 +00:00
|
|
|
WARN_ON(cur_trans != info->running_transaction);
|
2007-03-23 14:01:08 +00:00
|
|
|
WARN_ON(cur_trans->num_writers < 1);
|
2007-06-28 19:57:36 +00:00
|
|
|
cur_trans->num_writers--;
|
2008-06-25 20:01:31 +00:00
|
|
|
|
2007-03-22 19:59:16 +00:00
|
|
|
if (waitqueue_active(&cur_trans->writer_wait))
|
|
|
|
wake_up(&cur_trans->writer_wait);
|
|
|
|
put_transaction(cur_trans);
|
2010-06-21 18:48:16 +00:00
|
|
|
if (lock)
|
|
|
|
mutex_unlock(&info->trans_mutex);
|
2009-09-11 20:12:44 +00:00
|
|
|
|
|
|
|
if (current->journal_info == trans)
|
|
|
|
current->journal_info = NULL;
|
2007-03-30 18:27:56 +00:00
|
|
|
memset(trans, 0, sizeof(*trans));
|
2007-04-02 14:50:19 +00:00
|
|
|
kmem_cache_free(btrfs_trans_handle_cachep, trans);
|
2008-07-29 20:15:18 +00:00
|
|
|
|
2009-11-12 09:36:34 +00:00
|
|
|
if (throttle)
|
|
|
|
btrfs_run_delayed_iputs(root);
|
|
|
|
|
2007-03-22 19:59:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-06-25 20:01:31 +00:00
|
|
|
int btrfs_end_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
2010-06-21 18:48:16 +00:00
|
|
|
return __btrfs_end_transaction(trans, root, 0, 1);
|
2008-06-25 20:01:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
2010-06-21 18:48:16 +00:00
|
|
|
return __btrfs_end_transaction(trans, root, 1, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
return __btrfs_end_transaction(trans, root, 0, 0);
|
2008-06-25 20:01:31 +00:00
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
|
|
|
* when btree blocks are allocated, they have some corresponding bits set for
|
|
|
|
* them in one of two extent_io trees. This is used to make sure all of
|
2009-10-13 17:29:19 +00:00
|
|
|
* those extents are sent to disk but does not wait on them
|
2008-09-29 19:18:18 +00:00
|
|
|
*/
|
2009-10-13 17:29:19 +00:00
|
|
|
int btrfs_write_marked_extents(struct btrfs_root *root,
|
2009-11-12 09:33:26 +00:00
|
|
|
struct extent_io_tree *dirty_pages, int mark)
|
2007-03-22 19:59:16 +00:00
|
|
|
{
|
2007-04-28 13:29:35 +00:00
|
|
|
int ret;
|
2008-08-15 19:34:15 +00:00
|
|
|
int err = 0;
|
2007-04-28 13:29:35 +00:00
|
|
|
int werr = 0;
|
|
|
|
struct page *page;
|
|
|
|
struct inode *btree_inode = root->fs_info->btree_inode;
|
2008-08-15 19:34:15 +00:00
|
|
|
u64 start = 0;
|
2007-10-15 20:14:19 +00:00
|
|
|
u64 end;
|
|
|
|
unsigned long index;
|
2007-04-28 13:29:35 +00:00
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
while (1) {
|
2008-08-15 19:34:15 +00:00
|
|
|
ret = find_first_extent_bit(dirty_pages, start, &start, &end,
|
2009-11-12 09:33:26 +00:00
|
|
|
mark);
|
2007-10-15 20:14:19 +00:00
|
|
|
if (ret)
|
2007-04-28 13:29:35 +00:00
|
|
|
break;
|
2009-01-06 02:25:51 +00:00
|
|
|
while (start <= end) {
|
2008-08-15 19:34:15 +00:00
|
|
|
cond_resched();
|
|
|
|
|
2007-10-15 20:14:19 +00:00
|
|
|
index = start >> PAGE_CACHE_SHIFT;
|
2007-10-30 20:56:53 +00:00
|
|
|
start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
|
2008-09-08 15:18:08 +00:00
|
|
|
page = find_get_page(btree_inode->i_mapping, index);
|
2007-04-28 13:29:35 +00:00
|
|
|
if (!page)
|
|
|
|
continue;
|
2008-09-08 15:18:08 +00:00
|
|
|
|
|
|
|
btree_lock_page_hook(page);
|
|
|
|
if (!page->mapping) {
|
|
|
|
unlock_page(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-08-07 20:15:09 +00:00
|
|
|
if (PageWriteback(page)) {
|
|
|
|
if (PageDirty(page))
|
|
|
|
wait_on_page_writeback(page);
|
|
|
|
else {
|
|
|
|
unlock_page(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2007-04-28 13:29:35 +00:00
|
|
|
err = write_one_page(page, 0);
|
|
|
|
if (err)
|
|
|
|
werr = err;
|
|
|
|
page_cache_release(page);
|
|
|
|
}
|
|
|
|
}
|
2009-10-13 17:29:19 +00:00
|
|
|
if (err)
|
|
|
|
werr = err;
|
|
|
|
return werr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* when btree blocks are allocated, they have some corresponding bits set for
|
|
|
|
* them in one of two extent_io trees. This is used to make sure all of
|
|
|
|
* those extents are on disk for transaction or log commit. We wait
|
|
|
|
* on all the pages and clear them from the dirty pages state tree
|
|
|
|
*/
|
|
|
|
int btrfs_wait_marked_extents(struct btrfs_root *root,
|
2009-11-12 09:33:26 +00:00
|
|
|
struct extent_io_tree *dirty_pages, int mark)
|
2009-10-13 17:29:19 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int err = 0;
|
|
|
|
int werr = 0;
|
|
|
|
struct page *page;
|
|
|
|
struct inode *btree_inode = root->fs_info->btree_inode;
|
|
|
|
u64 start = 0;
|
|
|
|
u64 end;
|
|
|
|
unsigned long index;
|
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
while (1) {
|
2009-11-12 09:33:26 +00:00
|
|
|
ret = find_first_extent_bit(dirty_pages, start, &start, &end,
|
|
|
|
mark);
|
2008-08-15 19:34:15 +00:00
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
|
2009-11-12 09:33:26 +00:00
|
|
|
clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
|
2009-01-06 02:25:51 +00:00
|
|
|
while (start <= end) {
|
2008-08-15 19:34:15 +00:00
|
|
|
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 15:18:08 +00:00
|
|
|
btree_lock_page_hook(page);
|
|
|
|
wait_on_page_writeback(page);
|
2008-08-15 19:34:15 +00:00
|
|
|
err = write_one_page(page, 0);
|
|
|
|
if (err)
|
|
|
|
werr = err;
|
|
|
|
}
|
2008-11-18 17:13:12 +00:00
|
|
|
wait_on_page_writeback(page);
|
2008-08-15 19:34:15 +00:00
|
|
|
page_cache_release(page);
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
}
|
2007-04-28 13:29:35 +00:00
|
|
|
if (err)
|
|
|
|
werr = err;
|
|
|
|
return werr;
|
2007-03-22 19:59:16 +00:00
|
|
|
}
|
|
|
|
|
2009-10-13 17:29:19 +00:00
|
|
|
/*
|
|
|
|
* when btree blocks are allocated, they have some corresponding bits set for
|
|
|
|
* them in one of two extent_io trees. This is used to make sure all of
|
|
|
|
* those extents are on disk for transaction or log commit
|
|
|
|
*/
|
|
|
|
int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
|
2009-11-12 09:33:26 +00:00
|
|
|
struct extent_io_tree *dirty_pages, int mark)
|
2009-10-13 17:29:19 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int ret2;
|
|
|
|
|
2009-11-12 09:33:26 +00:00
|
|
|
ret = btrfs_write_marked_extents(root, dirty_pages, mark);
|
|
|
|
ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
|
2009-10-13 17:29:19 +00:00
|
|
|
return ret || ret2;
|
|
|
|
}
|
|
|
|
|
2008-09-11 20:17:57 +00: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,
|
2009-11-12 09:33:26 +00:00
|
|
|
&trans->transaction->dirty_pages,
|
|
|
|
EXTENT_DIRTY);
|
2008-09-11 20:17:57 +00:00
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
|
|
|
* this is used to update the root pointer in the tree of tree roots.
|
|
|
|
*
|
|
|
|
* But, in the case of the extent allocation tree, updating the root
|
|
|
|
* pointer may allocate blocks which may change the root of the extent
|
|
|
|
* allocation tree.
|
|
|
|
*
|
|
|
|
* So, this loops and repeats and makes sure the cowonly root didn't
|
|
|
|
* change while the root pointer was being updated in the metadata.
|
|
|
|
*/
|
2008-03-24 19:01:56 +00:00
|
|
|
static int update_cowonly_root(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
2007-03-22 19:59:16 +00:00
|
|
|
{
|
|
|
|
int ret;
|
2008-03-24 19:01:56 +00:00
|
|
|
u64 old_root_bytenr;
|
2009-11-12 09:36:50 +00:00
|
|
|
u64 old_root_used;
|
2008-03-24 19:01:56 +00:00
|
|
|
struct btrfs_root *tree_root = root->fs_info->tree_root;
|
2007-03-22 19:59:16 +00:00
|
|
|
|
2009-11-12 09:36:50 +00:00
|
|
|
old_root_used = btrfs_root_used(&root->root_item);
|
2008-03-24 19:01:56 +00:00
|
|
|
btrfs_write_dirty_block_groups(trans, root);
|
2009-03-13 14:10:06 +00:00
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
while (1) {
|
2008-03-24 19:01:56 +00:00
|
|
|
old_root_bytenr = btrfs_root_bytenr(&root->root_item);
|
2009-11-12 09:36:50 +00:00
|
|
|
if (old_root_bytenr == root->node->start &&
|
|
|
|
old_root_used == btrfs_root_used(&root->root_item))
|
2007-03-22 19:59:16 +00:00
|
|
|
break;
|
2008-10-30 15:23:27 +00:00
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
btrfs_set_root_node(&root->root_item, root->node);
|
2007-03-22 19:59:16 +00:00
|
|
|
ret = btrfs_update_root(trans, tree_root,
|
2008-03-24 19:01:56 +00:00
|
|
|
&root->root_key,
|
|
|
|
&root->root_item);
|
2007-03-22 19:59:16 +00:00
|
|
|
BUG_ON(ret);
|
2009-03-13 14:10:06 +00:00
|
|
|
|
2009-11-12 09:36:50 +00:00
|
|
|
old_root_used = btrfs_root_used(&root->root_item);
|
2009-07-22 14:07:05 +00:00
|
|
|
ret = btrfs_write_dirty_block_groups(trans, root);
|
2009-03-13 14:10:06 +00:00
|
|
|
BUG_ON(ret);
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
2009-07-30 13:40:40 +00:00
|
|
|
|
|
|
|
if (root != root->fs_info->extent_root)
|
|
|
|
switch_commit_root(root);
|
|
|
|
|
2008-03-24 19:01:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
|
|
|
* update all the cowonly tree roots on disk
|
|
|
|
*/
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
2008-03-24 19:01:56 +00:00
|
|
|
{
|
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
|
|
struct list_head *next;
|
2008-10-29 18:49:05 +00:00
|
|
|
struct extent_buffer *eb;
|
2009-03-13 14:10:06 +00:00
|
|
|
int ret;
|
2008-10-29 18:49:05 +00:00
|
|
|
|
2009-03-13 14:10:06 +00:00
|
|
|
ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
|
|
|
|
BUG_ON(ret);
|
2008-10-30 15:23:27 +00:00
|
|
|
|
2008-10-29 18:49:05 +00:00
|
|
|
eb = btrfs_lock_root_node(fs_info->tree_root);
|
2009-03-13 14:24:59 +00:00
|
|
|
btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
|
2008-10-29 18:49:05 +00:00
|
|
|
btrfs_tree_unlock(eb);
|
|
|
|
free_extent_buffer(eb);
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2009-03-13 14:10:06 +00:00
|
|
|
ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
|
|
|
|
BUG_ON(ret);
|
2008-10-30 15:23:27 +00:00
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
while (!list_empty(&fs_info->dirty_cowonly_roots)) {
|
2008-03-24 19:01:56 +00:00
|
|
|
next = fs_info->dirty_cowonly_roots.next;
|
|
|
|
list_del_init(next);
|
|
|
|
root = list_entry(next, struct btrfs_root, dirty_list);
|
2008-10-30 15:23:27 +00:00
|
|
|
|
2008-03-24 19:01:56 +00:00
|
|
|
update_cowonly_root(trans, root);
|
2007-03-22 19:59:16 +00:00
|
|
|
}
|
2009-07-30 13:40:40 +00:00
|
|
|
|
|
|
|
down_write(&fs_info->extent_commit_sem);
|
|
|
|
switch_commit_root(fs_info->extent_root);
|
|
|
|
up_write(&fs_info->extent_commit_sem);
|
|
|
|
|
2007-03-22 19:59:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
|
|
|
* dead roots are old snapshots that need to be deleted. This allocates
|
|
|
|
* a dirty root struct and adds it into the list of dead roots that need to
|
|
|
|
* be deleted
|
|
|
|
*/
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
int btrfs_add_dead_root(struct btrfs_root *root)
|
2007-06-22 18:16:25 +00:00
|
|
|
{
|
2008-08-05 03:23:47 +00:00
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
list_add(&root->root_list, &root->fs_info->dead_roots);
|
2008-08-05 03:23:47 +00:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2007-06-22 18:16:25 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
* update all the cowonly tree roots on disk
|
2008-09-29 19:18:18 +00:00
|
|
|
*/
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
2007-04-09 14:42:37 +00:00
|
|
|
{
|
|
|
|
struct btrfs_root *gang[8];
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
2007-04-09 14:42:37 +00:00
|
|
|
int i;
|
|
|
|
int ret;
|
2007-06-22 18:16:25 +00:00
|
|
|
int err = 0;
|
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
while (1) {
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
|
|
|
|
(void **)gang, 0,
|
2007-04-09 14:42:37 +00:00
|
|
|
ARRAY_SIZE(gang),
|
|
|
|
BTRFS_ROOT_TRANS_TAG);
|
|
|
|
if (ret == 0)
|
|
|
|
break;
|
|
|
|
for (i = 0; i < ret; i++) {
|
|
|
|
root = gang[i];
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
radix_tree_tag_clear(&fs_info->fs_roots_radix,
|
|
|
|
(unsigned long)root->root_key.objectid,
|
|
|
|
BTRFS_ROOT_TRANS_TAG);
|
2008-07-28 19:32:19 +00:00
|
|
|
|
2008-09-05 20:13:11 +00:00
|
|
|
btrfs_free_log(trans, root);
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
btrfs_update_reloc_root(trans, root);
|
2010-05-16 14:49:58 +00:00
|
|
|
btrfs_orphan_commit_root(trans, root);
|
2008-07-30 20:29:20 +00:00
|
|
|
|
2009-06-16 00:01:02 +00:00
|
|
|
if (root->commit_root != root->node) {
|
Btrfs: async block group caching
This patch moves the caching of the block group off to a kthread in order to
allow people to allocate sooner. Instead of blocking up behind the caching
mutex, we instead kick of the caching kthread, and then attempt to make an
allocation. If we cannot, we wait on the block groups caching waitqueue, which
the caching kthread will wake the waiting threads up everytime it finds 2 meg
worth of space, and then again when its finished caching. This is how I tested
the speedup from this
mkfs the disk
mount the disk
fill the disk up with fs_mark
unmount the disk
mount the disk
time touch /mnt/foo
Without my changes this took 11 seconds on my box, with these changes it now
takes 1 second.
Another change thats been put in place is we lock the super mirror's in the
pinned extent map in order to keep us from adding that stuff as free space when
caching the block group. This doesn't really change anything else as far as the
pinned extent map is concerned, since for actual pinned extents we use
EXTENT_DIRTY, but it does mean that when we unmount we have to go in and unlock
those extents to keep from leaking memory.
I've also added a check where when we are reading block groups from disk, if the
amount of space used == the size of the block group, we go ahead and mark the
block group as cached. This drastically reduces the amount of time it takes to
cache the block groups. Using the same test as above, except doing a dd to a
file and then unmounting, it used to take 33 seconds to umount, now it takes 3
seconds.
This version uses the commit_root in the caching kthread, and then keeps track
of how many async caching threads are running at any given time so if one of the
async threads is still running as we cross transactions we can wait until its
finished before handling the pinned extents. Thank you,
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-07-14 01:29:25 +00:00
|
|
|
switch_commit_root(root);
|
2009-06-16 00:01:02 +00:00
|
|
|
btrfs_set_root_node(&root->root_item,
|
|
|
|
root->node);
|
|
|
|
}
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
|
|
|
|
err = btrfs_update_root(trans, fs_info->tree_root,
|
2007-04-09 14:42:37 +00:00
|
|
|
&root->root_key,
|
|
|
|
&root->root_item);
|
2007-06-22 18:16:25 +00:00
|
|
|
if (err)
|
|
|
|
break;
|
2007-04-09 14:42:37 +00:00
|
|
|
}
|
|
|
|
}
|
2007-06-22 18:16:25 +00:00
|
|
|
return err;
|
2007-04-09 14:42:37 +00:00
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
|
|
|
* defrag a given btree. If cacheonly == 1, this won't read from the disk,
|
|
|
|
* otherwise every leaf in the btree is read and defragged.
|
|
|
|
*/
|
2007-08-10 18:06:19 +00:00
|
|
|
int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
|
|
|
|
{
|
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
|
|
|
struct btrfs_trans_handle *trans;
|
2010-05-16 14:49:58 +00:00
|
|
|
int ret;
|
2007-09-17 14:58:06 +00:00
|
|
|
unsigned long nr;
|
2007-08-10 18:06:19 +00:00
|
|
|
|
2010-05-16 14:49:58 +00:00
|
|
|
if (xchg(&root->defrag_running, 1))
|
2007-08-10 18:06:19 +00:00
|
|
|
return 0;
|
2010-05-16 14:49:58 +00:00
|
|
|
|
2007-10-15 20:17:34 +00:00
|
|
|
while (1) {
|
2010-05-16 14:49:58 +00:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
|
|
|
if (IS_ERR(trans))
|
|
|
|
return PTR_ERR(trans);
|
|
|
|
|
2007-08-10 18:06:19 +00:00
|
|
|
ret = btrfs_defrag_leaves(trans, root, cacheonly);
|
2010-05-16 14:49:58 +00:00
|
|
|
|
2007-09-17 14:58:06 +00:00
|
|
|
nr = trans->blocks_used;
|
2007-08-10 18:06:19 +00:00
|
|
|
btrfs_end_transaction(trans, root);
|
2007-09-17 14:58:06 +00:00
|
|
|
btrfs_btree_balance_dirty(info->tree_root, nr);
|
2007-08-10 18:06:19 +00:00
|
|
|
cond_resched();
|
|
|
|
|
2008-06-25 20:01:31 +00:00
|
|
|
if (root->fs_info->closing || ret != -EAGAIN)
|
2007-08-10 18:06:19 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
root->defrag_running = 0;
|
2010-05-16 14:49:58 +00:00
|
|
|
return ret;
|
2007-08-10 18:06:19 +00:00
|
|
|
}
|
|
|
|
|
2009-06-28 01:07:35 +00:00
|
|
|
#if 0
|
2009-03-13 00:12:45 +00:00
|
|
|
/*
|
|
|
|
* when dropping snapshots, we generate a ton of delayed refs, and it makes
|
|
|
|
* sense not to join the transaction while it is trying to flush the current
|
|
|
|
* queue of delayed refs out.
|
|
|
|
*
|
|
|
|
* This is used by the drop snapshot code only
|
|
|
|
*/
|
|
|
|
static noinline int wait_transaction_pre_flush(struct btrfs_fs_info *info)
|
|
|
|
{
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
|
|
|
|
mutex_lock(&info->trans_mutex);
|
|
|
|
while (info->running_transaction &&
|
|
|
|
info->running_transaction->delayed_refs.flushing) {
|
|
|
|
prepare_to_wait(&info->transaction_wait, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
mutex_unlock(&info->trans_mutex);
|
2009-04-24 18:39:25 +00:00
|
|
|
|
2009-03-13 00:12:45 +00:00
|
|
|
schedule();
|
2009-04-24 18:39:25 +00:00
|
|
|
|
2009-03-13 00:12:45 +00:00
|
|
|
mutex_lock(&info->trans_mutex);
|
|
|
|
finish_wait(&info->transaction_wait, &wait);
|
|
|
|
}
|
|
|
|
mutex_unlock(&info->trans_mutex);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
|
|
|
* Given a list of roots that need to be deleted, call btrfs_drop_snapshot on
|
|
|
|
* all of them
|
|
|
|
*/
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
int btrfs_drop_dead_root(struct btrfs_root *root)
|
2007-04-09 14:42:37 +00:00
|
|
|
{
|
|
|
|
struct btrfs_trans_handle *trans;
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
struct btrfs_root *tree_root = root->fs_info->tree_root;
|
2007-09-17 14:58:06 +00:00
|
|
|
unsigned long nr;
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
int ret;
|
2007-08-29 19:47:34 +00:00
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
while (1) {
|
|
|
|
/*
|
|
|
|
* we don't want to jump in and create a bunch of
|
|
|
|
* delayed refs if the transaction is starting to close
|
|
|
|
*/
|
|
|
|
wait_transaction_pre_flush(tree_root->fs_info);
|
|
|
|
trans = btrfs_start_transaction(tree_root, 1);
|
2008-06-25 20:01:30 +00:00
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
/*
|
|
|
|
* we've joined a transaction, make sure it isn't
|
|
|
|
* closing right now
|
|
|
|
*/
|
|
|
|
if (trans->transaction->delayed_refs.flushing) {
|
|
|
|
btrfs_end_transaction(trans, tree_root);
|
|
|
|
continue;
|
2007-08-07 19:52:19 +00:00
|
|
|
}
|
2007-08-29 19:47:34 +00:00
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
ret = btrfs_drop_snapshot(trans, root);
|
|
|
|
if (ret != -EAGAIN)
|
|
|
|
break;
|
2008-06-25 20:01:30 +00:00
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
ret = btrfs_update_root(trans, tree_root,
|
|
|
|
&root->root_key,
|
|
|
|
&root->root_item);
|
|
|
|
if (ret)
|
2007-06-22 18:16:25 +00:00
|
|
|
break;
|
2008-07-30 20:29:20 +00:00
|
|
|
|
2007-09-17 14:58:06 +00:00
|
|
|
nr = trans->blocks_used;
|
2007-04-09 14:42:37 +00:00
|
|
|
ret = btrfs_end_transaction(trans, tree_root);
|
|
|
|
BUG_ON(ret);
|
2007-06-22 18:16:25 +00:00
|
|
|
|
2007-09-17 14:58:06 +00:00
|
|
|
btrfs_btree_balance_dirty(tree_root, nr);
|
2007-10-15 20:18:14 +00:00
|
|
|
cond_resched();
|
2007-04-09 14:42:37 +00:00
|
|
|
}
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
BUG_ON(ret);
|
|
|
|
|
|
|
|
ret = btrfs_del_root(trans, tree_root, &root->root_key);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
|
|
|
nr = trans->blocks_used;
|
|
|
|
ret = btrfs_end_transaction(trans, tree_root);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
|
|
|
free_extent_buffer(root->node);
|
|
|
|
free_extent_buffer(root->commit_root);
|
|
|
|
kfree(root);
|
|
|
|
|
|
|
|
btrfs_btree_balance_dirty(tree_root, nr);
|
2007-06-22 18:16:25 +00:00
|
|
|
return ret;
|
2007-04-09 14:42:37 +00:00
|
|
|
}
|
2009-06-28 01:07:35 +00:00
|
|
|
#endif
|
2007-04-09 14:42:37 +00:00
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
|
|
|
* new snapshots need to be created at a very specific time in the
|
|
|
|
* transaction commit. This does the actual creation
|
|
|
|
*/
|
2008-02-01 21:35:04 +00:00
|
|
|
static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
|
2008-01-08 20:46:30 +00:00
|
|
|
struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_pending_snapshot *pending)
|
|
|
|
{
|
|
|
|
struct btrfs_key key;
|
2008-02-01 21:35:04 +00:00
|
|
|
struct btrfs_root_item *new_root_item;
|
2008-01-08 20:46:30 +00:00
|
|
|
struct btrfs_root *tree_root = fs_info->tree_root;
|
|
|
|
struct btrfs_root *root = pending->root;
|
2010-03-15 17:27:13 +00:00
|
|
|
struct btrfs_root *parent_root;
|
|
|
|
struct inode *parent_inode;
|
2010-05-16 14:48:46 +00:00
|
|
|
struct dentry *dentry;
|
2008-01-08 20:46:30 +00:00
|
|
|
struct extent_buffer *tmp;
|
2008-06-25 20:01:30 +00:00
|
|
|
struct extent_buffer *old;
|
2008-01-08 20:46:30 +00:00
|
|
|
int ret;
|
2010-05-16 14:49:58 +00:00
|
|
|
int retries = 0;
|
|
|
|
u64 to_reserve = 0;
|
2010-03-15 17:27:13 +00:00
|
|
|
u64 index = 0;
|
2010-05-16 14:48:46 +00:00
|
|
|
u64 objectid;
|
2008-01-08 20:46:30 +00:00
|
|
|
|
2008-02-01 21:35:04 +00:00
|
|
|
new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
|
|
|
|
if (!new_root_item) {
|
2010-05-16 14:48:46 +00:00
|
|
|
pending->error = -ENOMEM;
|
2008-02-01 21:35:04 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
2010-05-16 14:48:46 +00:00
|
|
|
|
2008-01-08 20:46:30 +00:00
|
|
|
ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid);
|
2010-05-16 14:48:46 +00:00
|
|
|
if (ret) {
|
|
|
|
pending->error = ret;
|
2008-01-08 20:46:30 +00:00
|
|
|
goto fail;
|
2010-05-16 14:48:46 +00:00
|
|
|
}
|
2008-01-08 20:46:30 +00:00
|
|
|
|
2010-05-16 14:49:59 +00:00
|
|
|
btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
|
2010-05-16 14:49:58 +00:00
|
|
|
btrfs_orphan_pre_snapshot(trans, pending, &to_reserve);
|
|
|
|
|
|
|
|
if (to_reserve > 0) {
|
|
|
|
ret = btrfs_block_rsv_add(trans, root, &pending->block_rsv,
|
|
|
|
to_reserve, &retries);
|
|
|
|
if (ret) {
|
|
|
|
pending->error = ret;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-08 20:46:30 +00:00
|
|
|
key.objectid = objectid;
|
2010-05-16 14:48:46 +00:00
|
|
|
key.offset = (u64)-1;
|
|
|
|
key.type = BTRFS_ROOT_ITEM_KEY;
|
2008-01-08 20:46:30 +00:00
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
trans->block_rsv = &pending->block_rsv;
|
2008-11-18 02:02:50 +00:00
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
dentry = pending->dentry;
|
|
|
|
parent_inode = dentry->d_parent->d_inode;
|
|
|
|
parent_root = BTRFS_I(parent_inode)->root;
|
2010-03-15 17:27:13 +00:00
|
|
|
record_root_in_trans(trans, parent_root);
|
2010-05-16 14:48:46 +00:00
|
|
|
|
2008-01-08 20:46:30 +00:00
|
|
|
/*
|
|
|
|
* insert the directory item
|
|
|
|
*/
|
2008-11-18 02:02:50 +00:00
|
|
|
ret = btrfs_set_inode_index(parent_inode, &index);
|
2010-03-15 17:27:13 +00:00
|
|
|
BUG_ON(ret);
|
2008-11-18 01:37:39 +00:00
|
|
|
ret = btrfs_insert_dir_item(trans, parent_root,
|
2010-05-16 14:48:46 +00:00
|
|
|
dentry->d_name.name, dentry->d_name.len,
|
|
|
|
parent_inode->i_ino, &key,
|
|
|
|
BTRFS_FT_DIR, index);
|
2010-03-15 17:27:13 +00:00
|
|
|
BUG_ON(ret);
|
2008-11-18 01:37:39 +00:00
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
btrfs_i_size_write(parent_inode, parent_inode->i_size +
|
|
|
|
dentry->d_name.len * 2);
|
2009-01-05 20:43:43 +00:00
|
|
|
ret = btrfs_update_inode(trans, parent_root, parent_inode);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
2010-03-15 17:27:13 +00:00
|
|
|
record_root_in_trans(trans, root);
|
|
|
|
btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
|
|
|
|
memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
|
|
|
|
|
|
|
|
old = btrfs_lock_root_node(root);
|
|
|
|
btrfs_cow_block(trans, root, old, NULL, 0, &old);
|
|
|
|
btrfs_set_lock_blocking(old);
|
|
|
|
|
|
|
|
btrfs_copy_root(trans, root, old, &tmp, objectid);
|
|
|
|
btrfs_tree_unlock(old);
|
|
|
|
free_extent_buffer(old);
|
|
|
|
|
|
|
|
btrfs_set_root_node(new_root_item, tmp);
|
2010-05-16 14:48:46 +00:00
|
|
|
/* record when the snapshot was created in key.offset */
|
|
|
|
key.offset = trans->transid;
|
|
|
|
ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
|
2010-03-15 17:27:13 +00:00
|
|
|
btrfs_tree_unlock(tmp);
|
|
|
|
free_extent_buffer(tmp);
|
2010-05-16 14:48:46 +00:00
|
|
|
BUG_ON(ret);
|
2010-03-15 17:27:13 +00:00
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
/*
|
|
|
|
* insert root back/forward references
|
|
|
|
*/
|
|
|
|
ret = btrfs_add_root_ref(trans, tree_root, objectid,
|
2008-11-18 01:37:39 +00:00
|
|
|
parent_root->root_key.objectid,
|
2010-05-16 14:48:46 +00:00
|
|
|
parent_inode->i_ino, index,
|
|
|
|
dentry->d_name.name, dentry->d_name.len);
|
2008-11-18 01:37:39 +00:00
|
|
|
BUG_ON(ret);
|
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
key.offset = (u64)-1;
|
|
|
|
pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
|
|
|
|
BUG_ON(IS_ERR(pending->snap));
|
2010-05-16 14:49:58 +00:00
|
|
|
|
2010-05-16 14:49:59 +00:00
|
|
|
btrfs_reloc_post_snapshot(trans, pending);
|
2010-05-16 14:49:58 +00:00
|
|
|
btrfs_orphan_post_snapshot(trans, pending);
|
2008-01-08 20:46:30 +00:00
|
|
|
fail:
|
2010-03-15 17:27:13 +00:00
|
|
|
kfree(new_root_item);
|
2010-05-16 14:48:46 +00:00
|
|
|
btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
|
|
|
|
return 0;
|
2008-01-08 20:46:30 +00:00
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
|
|
|
* create all the snapshots we've scheduled for creation
|
|
|
|
*/
|
2008-02-01 21:35:04 +00:00
|
|
|
static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info)
|
2008-11-18 02:02:50 +00:00
|
|
|
{
|
|
|
|
struct btrfs_pending_snapshot *pending;
|
|
|
|
struct list_head *head = &trans->transaction->pending_snapshots;
|
|
|
|
int ret;
|
|
|
|
|
2009-01-21 15:59:08 +00:00
|
|
|
list_for_each_entry(pending, head, list) {
|
2008-11-18 02:02:50 +00:00
|
|
|
ret = create_pending_snapshot(trans, fs_info, pending);
|
|
|
|
BUG_ON(ret);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
static void update_super_roots(struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
struct btrfs_root_item *root_item;
|
|
|
|
struct btrfs_super_block *super;
|
|
|
|
|
|
|
|
super = &root->fs_info->super_copy;
|
|
|
|
|
|
|
|
root_item = &root->fs_info->chunk_root->root_item;
|
|
|
|
super->chunk_root = root_item->bytenr;
|
|
|
|
super->chunk_root_generation = root_item->generation;
|
|
|
|
super->chunk_root_level = root_item->level;
|
|
|
|
|
|
|
|
root_item = &root->fs_info->tree_root->root_item;
|
|
|
|
super->root = root_item->bytenr;
|
|
|
|
super->generation = root_item->generation;
|
|
|
|
super->root_level = root_item->level;
|
2010-06-21 18:48:16 +00:00
|
|
|
if (super->cache_generation != 0 || btrfs_test_opt(root, SPACE_CACHE))
|
|
|
|
super->cache_generation = root_item->generation;
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
}
|
|
|
|
|
2009-07-30 14:04:48 +00:00
|
|
|
int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
spin_lock(&info->new_trans_lock);
|
|
|
|
if (info->running_transaction)
|
|
|
|
ret = info->running_transaction->in_commit;
|
|
|
|
spin_unlock(&info->new_trans_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-05-16 14:49:58 +00:00
|
|
|
int btrfs_transaction_blocked(struct btrfs_fs_info *info)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
spin_lock(&info->new_trans_lock);
|
|
|
|
if (info->running_transaction)
|
|
|
|
ret = info->running_transaction->blocked;
|
|
|
|
spin_unlock(&info->new_trans_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-03-22 19:59:16 +00:00
|
|
|
int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
2007-08-10 20:22:09 +00:00
|
|
|
unsigned long joined = 0;
|
|
|
|
unsigned long timeout = 1;
|
2007-03-22 19:59:16 +00:00
|
|
|
struct btrfs_transaction *cur_trans;
|
2007-04-20 01:01:03 +00:00
|
|
|
struct btrfs_transaction *prev_trans = NULL;
|
2007-03-22 19:59:16 +00:00
|
|
|
DEFINE_WAIT(wait);
|
2007-08-10 20:22:09 +00:00
|
|
|
int ret;
|
2009-03-13 00:12:45 +00:00
|
|
|
int should_grow = 0;
|
|
|
|
unsigned long now = get_seconds();
|
2009-04-02 20:59:01 +00:00
|
|
|
int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
|
2007-03-22 19:59:16 +00:00
|
|
|
|
2009-03-31 17:27:11 +00:00
|
|
|
btrfs_run_ordered_operations(root, 0);
|
|
|
|
|
2009-03-13 14:10:06 +00:00
|
|
|
/* make a pass through all the delayed refs we have so far
|
|
|
|
* any runnings procs may add more while we are here
|
|
|
|
*/
|
|
|
|
ret = btrfs_run_delayed_refs(trans, root, 0);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
btrfs_trans_release_metadata(trans, root);
|
|
|
|
|
2009-03-13 00:12:45 +00:00
|
|
|
cur_trans = trans->transaction;
|
2009-03-13 14:10:06 +00:00
|
|
|
/*
|
|
|
|
* set the flushing flag so procs in this transaction have to
|
|
|
|
* start sending their work down.
|
|
|
|
*/
|
2009-03-13 00:12:45 +00:00
|
|
|
cur_trans->delayed_refs.flushing = 1;
|
2009-03-13 14:10:06 +00:00
|
|
|
|
2009-03-13 14:17:05 +00:00
|
|
|
ret = btrfs_run_delayed_refs(trans, root, 0);
|
2009-03-13 14:10:06 +00:00
|
|
|
BUG_ON(ret);
|
|
|
|
|
2007-03-22 19:59:16 +00:00
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
2009-03-13 00:12:45 +00:00
|
|
|
if (cur_trans->in_commit) {
|
|
|
|
cur_trans->use_count++;
|
2007-06-28 19:57:36 +00:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2007-03-22 19:59:16 +00:00
|
|
|
btrfs_end_transaction(trans, root);
|
2007-06-28 19:57:36 +00:00
|
|
|
|
2007-03-22 19:59:16 +00:00
|
|
|
ret = wait_for_commit(root, cur_trans);
|
|
|
|
BUG_ON(ret);
|
2007-08-10 20:22:09 +00:00
|
|
|
|
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
2007-03-22 19:59:16 +00:00
|
|
|
put_transaction(cur_trans);
|
2007-08-10 20:22:09 +00:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
|
|
|
|
2007-03-22 19:59:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-01-03 14:08:48 +00:00
|
|
|
|
2007-04-02 14:50:19 +00:00
|
|
|
trans->transaction->in_commit = 1;
|
2008-07-17 16:54:14 +00:00
|
|
|
trans->transaction->blocked = 1;
|
2007-06-28 19:57:36 +00:00
|
|
|
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 20:22:09 +00:00
|
|
|
put_transaction(prev_trans);
|
2007-06-28 19:57:36 +00:00
|
|
|
}
|
|
|
|
}
|
2007-08-10 20:22:09 +00:00
|
|
|
|
2009-03-13 00:12:45 +00:00
|
|
|
if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
|
|
|
|
should_grow = 1;
|
|
|
|
|
2007-08-10 20:22:09 +00:00
|
|
|
do {
|
2008-08-05 17:05:02 +00:00
|
|
|
int snap_pending = 0;
|
2007-08-10 20:22:09 +00:00
|
|
|
joined = cur_trans->num_joined;
|
2008-08-05 17:05:02 +00:00
|
|
|
if (!list_empty(&trans->transaction->pending_snapshots))
|
|
|
|
snap_pending = 1;
|
|
|
|
|
2007-04-02 14:50:19 +00:00
|
|
|
WARN_ON(cur_trans != trans->transaction);
|
2007-08-10 20:22:09 +00:00
|
|
|
if (cur_trans->num_writers > 1)
|
|
|
|
timeout = MAX_SCHEDULE_TIMEOUT;
|
2009-03-13 00:12:45 +00:00
|
|
|
else if (should_grow)
|
2007-08-10 20:22:09 +00:00
|
|
|
timeout = 1;
|
|
|
|
|
2007-03-22 19:59:16 +00:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2007-08-10 20:22:09 +00:00
|
|
|
|
2010-02-19 22:13:50 +00:00
|
|
|
if (flush_on_commit || snap_pending) {
|
2009-11-12 09:36:34 +00:00
|
|
|
btrfs_start_delalloc_inodes(root, 1);
|
|
|
|
ret = btrfs_wait_ordered_extents(root, 0, 1);
|
2009-07-24 17:17:44 +00:00
|
|
|
BUG_ON(ret);
|
2008-08-05 17:05:02 +00:00
|
|
|
}
|
|
|
|
|
2009-03-31 17:27:11 +00:00
|
|
|
/*
|
|
|
|
* rename don't use btrfs_join_transaction, so, once we
|
|
|
|
* set the transaction to blocked above, we aren't going
|
|
|
|
* to get any new ordered operations. We can safely run
|
|
|
|
* it here and no for sure that nothing new will be added
|
|
|
|
* to the list
|
|
|
|
*/
|
|
|
|
btrfs_run_ordered_operations(root, 1);
|
|
|
|
|
2010-05-25 14:12:41 +00:00
|
|
|
prepare_to_wait(&cur_trans->writer_wait, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
|
2009-03-13 00:12:45 +00:00
|
|
|
smp_mb();
|
|
|
|
if (cur_trans->num_writers > 1 || should_grow)
|
|
|
|
schedule_timeout(timeout);
|
2007-08-10 20:22:09 +00:00
|
|
|
|
2007-03-22 19:59:16 +00:00
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
2007-08-10 20:22:09 +00:00
|
|
|
finish_wait(&cur_trans->writer_wait, &wait);
|
|
|
|
} while (cur_trans->num_writers > 1 ||
|
2009-03-13 00:12:45 +00:00
|
|
|
(should_grow && cur_trans->num_joined != joined));
|
2007-08-10 20:22:09 +00:00
|
|
|
|
2008-01-08 20:46:30 +00:00
|
|
|
ret = create_pending_snapshots(trans, root->fs_info);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
2009-03-13 14:10:06 +00:00
|
|
|
ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
2007-04-02 14:50:19 +00:00
|
|
|
WARN_ON(cur_trans != trans->transaction);
|
2008-01-08 20:46:30 +00:00
|
|
|
|
2008-09-05 20:13:11 +00: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: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
ret = commit_fs_roots(trans, root);
|
2007-06-22 18:16:25 +00:00
|
|
|
BUG_ON(ret);
|
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
/* commit_fs_roots gets rid of all the tree log roots, it is now
|
2008-09-05 20:13:11 +00:00
|
|
|
* safe to free the root of tree log roots
|
|
|
|
*/
|
|
|
|
btrfs_free_log_root_tree(trans, root->fs_info);
|
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
ret = commit_cowonly_roots(trans, root);
|
2007-03-22 19:59:16 +00:00
|
|
|
BUG_ON(ret);
|
2007-06-22 18:16:25 +00:00
|
|
|
|
2009-09-11 20:11:19 +00:00
|
|
|
btrfs_prepare_extent_commit(trans, root);
|
|
|
|
|
2007-03-25 15:35:08 +00:00
|
|
|
cur_trans = root->fs_info->running_transaction;
|
2008-01-15 13:40:48 +00:00
|
|
|
spin_lock(&root->fs_info->new_trans_lock);
|
2007-03-25 15:35:08 +00:00
|
|
|
root->fs_info->running_transaction = NULL;
|
2008-01-15 13:40:48 +00:00
|
|
|
spin_unlock(&root->fs_info->new_trans_lock);
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
|
|
|
|
btrfs_set_root_node(&root->fs_info->tree_root->root_item,
|
|
|
|
root->fs_info->tree_root->node);
|
Btrfs: async block group caching
This patch moves the caching of the block group off to a kthread in order to
allow people to allocate sooner. Instead of blocking up behind the caching
mutex, we instead kick of the caching kthread, and then attempt to make an
allocation. If we cannot, we wait on the block groups caching waitqueue, which
the caching kthread will wake the waiting threads up everytime it finds 2 meg
worth of space, and then again when its finished caching. This is how I tested
the speedup from this
mkfs the disk
mount the disk
fill the disk up with fs_mark
unmount the disk
mount the disk
time touch /mnt/foo
Without my changes this took 11 seconds on my box, with these changes it now
takes 1 second.
Another change thats been put in place is we lock the super mirror's in the
pinned extent map in order to keep us from adding that stuff as free space when
caching the block group. This doesn't really change anything else as far as the
pinned extent map is concerned, since for actual pinned extents we use
EXTENT_DIRTY, but it does mean that when we unmount we have to go in and unlock
those extents to keep from leaking memory.
I've also added a check where when we are reading block groups from disk, if the
amount of space used == the size of the block group, we go ahead and mark the
block group as cached. This drastically reduces the amount of time it takes to
cache the block groups. Using the same test as above, except doing a dd to a
file and then unmounting, it used to take 33 seconds to umount, now it takes 3
seconds.
This version uses the commit_root in the caching kthread, and then keeps track
of how many async caching threads are running at any given time so if one of the
async threads is still running as we cross transactions we can wait until its
finished before handling the pinned extents. Thank you,
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-07-14 01:29:25 +00:00
|
|
|
switch_commit_root(root->fs_info->tree_root);
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
|
|
|
|
btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
|
|
|
|
root->fs_info->chunk_root->node);
|
Btrfs: async block group caching
This patch moves the caching of the block group off to a kthread in order to
allow people to allocate sooner. Instead of blocking up behind the caching
mutex, we instead kick of the caching kthread, and then attempt to make an
allocation. If we cannot, we wait on the block groups caching waitqueue, which
the caching kthread will wake the waiting threads up everytime it finds 2 meg
worth of space, and then again when its finished caching. This is how I tested
the speedup from this
mkfs the disk
mount the disk
fill the disk up with fs_mark
unmount the disk
mount the disk
time touch /mnt/foo
Without my changes this took 11 seconds on my box, with these changes it now
takes 1 second.
Another change thats been put in place is we lock the super mirror's in the
pinned extent map in order to keep us from adding that stuff as free space when
caching the block group. This doesn't really change anything else as far as the
pinned extent map is concerned, since for actual pinned extents we use
EXTENT_DIRTY, but it does mean that when we unmount we have to go in and unlock
those extents to keep from leaking memory.
I've also added a check where when we are reading block groups from disk, if the
amount of space used == the size of the block group, we go ahead and mark the
block group as cached. This drastically reduces the amount of time it takes to
cache the block groups. Using the same test as above, except doing a dd to a
file and then unmounting, it used to take 33 seconds to umount, now it takes 3
seconds.
This version uses the commit_root in the caching kthread, and then keeps track
of how many async caching threads are running at any given time so if one of the
async threads is still running as we cross transactions we can wait until its
finished before handling the pinned extents. Thank you,
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-07-14 01:29:25 +00:00
|
|
|
switch_commit_root(root->fs_info->chunk_root);
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
|
|
|
|
update_super_roots(root);
|
2008-09-05 20:13:11 +00: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 15:43:44 +00:00
|
|
|
memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
|
|
|
|
sizeof(root->fs_info->super_copy));
|
2007-06-28 19:57:36 +00:00
|
|
|
|
2008-07-17 16:54:14 +00:00
|
|
|
trans->transaction->blocked = 0;
|
2009-03-13 00:12:45 +00:00
|
|
|
|
2008-07-17 16:54:14 +00:00
|
|
|
wake_up(&root->fs_info->transaction_wait);
|
2008-07-17 16:53:50 +00:00
|
|
|
|
2007-03-25 15:35:08 +00:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2007-03-22 19:59:16 +00:00
|
|
|
ret = btrfs_write_and_wait_transaction(trans, root);
|
|
|
|
BUG_ON(ret);
|
2008-12-08 21:46:26 +00:00
|
|
|
write_ctree_super(trans, root, 0);
|
2008-01-03 14:08:48 +00:00
|
|
|
|
2008-09-05 20:13:11 +00: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);
|
|
|
|
|
2009-09-11 20:11:19 +00:00
|
|
|
btrfs_finish_extent_commit(trans, root);
|
2008-01-03 14:08:48 +00:00
|
|
|
|
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 14:09:34 +00:00
|
|
|
mutex_lock(&root->fs_info->trans_mutex);
|
|
|
|
|
2007-04-02 14:50:19 +00:00
|
|
|
cur_trans->commit_done = 1;
|
2009-03-13 00:12:45 +00:00
|
|
|
|
2007-08-10 20:22:09 +00:00
|
|
|
root->fs_info->last_trans_committed = cur_trans->transid;
|
Btrfs: async block group caching
This patch moves the caching of the block group off to a kthread in order to
allow people to allocate sooner. Instead of blocking up behind the caching
mutex, we instead kick of the caching kthread, and then attempt to make an
allocation. If we cannot, we wait on the block groups caching waitqueue, which
the caching kthread will wake the waiting threads up everytime it finds 2 meg
worth of space, and then again when its finished caching. This is how I tested
the speedup from this
mkfs the disk
mount the disk
fill the disk up with fs_mark
unmount the disk
mount the disk
time touch /mnt/foo
Without my changes this took 11 seconds on my box, with these changes it now
takes 1 second.
Another change thats been put in place is we lock the super mirror's in the
pinned extent map in order to keep us from adding that stuff as free space when
caching the block group. This doesn't really change anything else as far as the
pinned extent map is concerned, since for actual pinned extents we use
EXTENT_DIRTY, but it does mean that when we unmount we have to go in and unlock
those extents to keep from leaking memory.
I've also added a check where when we are reading block groups from disk, if the
amount of space used == the size of the block group, we go ahead and mark the
block group as cached. This drastically reduces the amount of time it takes to
cache the block groups. Using the same test as above, except doing a dd to a
file and then unmounting, it used to take 33 seconds to umount, now it takes 3
seconds.
This version uses the commit_root in the caching kthread, and then keeps track
of how many async caching threads are running at any given time so if one of the
async threads is still running as we cross transactions we can wait until its
finished before handling the pinned extents. Thank you,
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-07-14 01:29:25 +00:00
|
|
|
|
2007-04-02 14:50:19 +00:00
|
|
|
wake_up(&cur_trans->commit_wait);
|
2008-11-18 02:02:50 +00:00
|
|
|
|
2007-03-25 15:35:08 +00:00
|
|
|
put_transaction(cur_trans);
|
2007-03-22 19:59:16 +00:00
|
|
|
put_transaction(cur_trans);
|
2007-08-29 19:47:34 +00:00
|
|
|
|
2007-03-25 15:35:08 +00:00
|
|
|
mutex_unlock(&root->fs_info->trans_mutex);
|
2008-11-18 02:02:50 +00:00
|
|
|
|
2009-09-11 20:12:44 +00:00
|
|
|
if (current->journal_info == trans)
|
|
|
|
current->journal_info = NULL;
|
|
|
|
|
2007-04-02 14:50:19 +00:00
|
|
|
kmem_cache_free(btrfs_trans_handle_cachep, trans);
|
2009-11-12 09:36:34 +00:00
|
|
|
|
|
|
|
if (current != root->fs_info->transaction_kthread)
|
|
|
|
btrfs_run_delayed_iputs(root);
|
|
|
|
|
2007-03-22 19:59:16 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-09-29 19:18:18 +00:00
|
|
|
/*
|
|
|
|
* interface function to delete all the snapshots we have scheduled for deletion
|
|
|
|
*/
|
2007-08-10 18:06:19 +00:00
|
|
|
int btrfs_clean_old_snapshots(struct btrfs_root *root)
|
|
|
|
{
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
LIST_HEAD(list);
|
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
|
|
|
|
|
|
mutex_lock(&fs_info->trans_mutex);
|
|
|
|
list_splice_init(&fs_info->dead_roots, &list);
|
|
|
|
mutex_unlock(&fs_info->trans_mutex);
|
2007-08-10 18:06:19 +00:00
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 14:45:14 +00:00
|
|
|
while (!list_empty(&list)) {
|
|
|
|
root = list_entry(list.next, struct btrfs_root, root_list);
|
2009-09-21 20:00:26 +00:00
|
|
|
list_del(&root->root_list);
|
|
|
|
|
|
|
|
if (btrfs_header_backref_rev(root->node) <
|
|
|
|
BTRFS_MIXED_BACKREF_REV)
|
2010-05-16 14:49:59 +00:00
|
|
|
btrfs_drop_snapshot(root, NULL, 0);
|
2009-09-21 20:00:26 +00:00
|
|
|
else
|
2010-05-16 14:49:59 +00:00
|
|
|
btrfs_drop_snapshot(root, NULL, 1);
|
2007-08-10 18:06:19 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|