2007-06-12 21:07:21 +08: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-23 03:59:16 +08: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 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2007-06-12 23:36:58 +08:00
|
|
|
#include <linux/sched.h>
|
2007-09-17 22:58:06 +08:00
|
|
|
#include <linux/writeback.h>
|
2007-10-16 04:14:19 +08:00
|
|
|
#include <linux/pagemap.h>
|
2008-11-08 07:22:45 +08:00
|
|
|
#include <linux/blkdev.h>
|
2012-07-25 23:35:53 +08:00
|
|
|
#include <linux/uuid.h>
|
2007-03-23 03:59:16 +08:00
|
|
|
#include "ctree.h"
|
|
|
|
#include "disk-io.h"
|
|
|
|
#include "transaction.h"
|
2008-06-26 04:01:30 +08:00
|
|
|
#include "locking.h"
|
2008-09-06 04:13:11 +08:00
|
|
|
#include "tree-log.h"
|
Btrfs: Cache free inode numbers in memory
Currently btrfs stores the highest objectid of the fs tree, and it always
returns (highest+1) inode number when we create a file, so inode numbers
won't be reclaimed when we delete files, so we'll run out of inode numbers
as we keep create/delete files in 32bits machines.
This fixes it, and it works similarly to how we cache free space in block
cgroups.
We start a kernel thread to read the file tree. By scanning inode items,
we know which chunks of inode numbers are free, and we cache them in
an rb-tree.
Because we are searching the commit root, we have to carefully handle the
cross-transaction case.
The rb-tree is a hybrid extent+bitmap tree, so if we have too many small
chunks of inode numbers, we'll use bitmaps. Initially we allow 16K ram
of extents, and a bitmap will be used if we exceed this threshold. The
extents threshold is adjusted in runtime.
Signed-off-by: Li Zefan <lizf@cn.fujitsu.com>
2011-04-20 10:06:11 +08:00
|
|
|
#include "inode-map.h"
|
2012-05-25 22:06:10 +08:00
|
|
|
#include "volumes.h"
|
2012-11-06 20:15:27 +08:00
|
|
|
#include "dev-replace.h"
|
2007-03-23 03:59:16 +08:00
|
|
|
|
2007-04-09 22:42:37 +08:00
|
|
|
#define BTRFS_ROOT_TRANS_TAG 0
|
|
|
|
|
2012-03-02 00:24:58 +08:00
|
|
|
void put_transaction(struct btrfs_transaction *transaction)
|
2007-03-23 03:59:16 +08:00
|
|
|
{
|
2011-04-12 03:45:29 +08:00
|
|
|
WARN_ON(atomic_read(&transaction->use_count) == 0);
|
|
|
|
if (atomic_dec_and_test(&transaction->use_count)) {
|
2011-04-12 05:25:13 +08:00
|
|
|
BUG_ON(!list_empty(&transaction->list));
|
2011-09-14 18:37:00 +08:00
|
|
|
WARN_ON(transaction->delayed_refs.root.rb_node);
|
2007-04-02 22:50:19 +08:00
|
|
|
memset(transaction, 0, sizeof(*transaction));
|
|
|
|
kmem_cache_free(btrfs_transaction_cachep, transaction);
|
2007-03-25 23:35:08 +08:00
|
|
|
}
|
2007-03-23 03:59:16 +08: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 09:29:25 +08: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-30 03:18:18 +08:00
|
|
|
/*
|
|
|
|
* either allocate a new transaction or hop into the existing one
|
|
|
|
*/
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
static noinline int join_transaction(struct btrfs_root *root, int type)
|
2007-03-23 03:59:16 +08:00
|
|
|
{
|
|
|
|
struct btrfs_transaction *cur_trans;
|
2012-05-20 21:42:19 +08:00
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
2011-04-12 05:25:13 +08:00
|
|
|
|
2012-05-20 21:42:19 +08:00
|
|
|
spin_lock(&fs_info->trans_lock);
|
2011-11-06 16:26:19 +08:00
|
|
|
loop:
|
2012-03-02 00:24:58 +08:00
|
|
|
/* The file system has been taken offline. No new transactions. */
|
2012-05-20 21:42:19 +08:00
|
|
|
if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
|
|
|
|
spin_unlock(&fs_info->trans_lock);
|
2012-03-02 00:24:58 +08:00
|
|
|
return -EROFS;
|
|
|
|
}
|
|
|
|
|
2012-05-20 21:42:19 +08:00
|
|
|
if (fs_info->trans_no_join) {
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
/*
|
|
|
|
* If we are JOIN_NOLOCK we're already committing a current
|
|
|
|
* transaction, we just need a handle to deal with something
|
|
|
|
* when committing the transaction, such as inode cache and
|
|
|
|
* space cache. It is a special case.
|
|
|
|
*/
|
|
|
|
if (type != TRANS_JOIN_NOLOCK) {
|
2012-05-20 21:42:19 +08:00
|
|
|
spin_unlock(&fs_info->trans_lock);
|
2011-04-12 05:25:13 +08:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-20 21:42:19 +08:00
|
|
|
cur_trans = fs_info->running_transaction;
|
2011-04-12 05:25:13 +08:00
|
|
|
if (cur_trans) {
|
2012-04-03 00:31:37 +08:00
|
|
|
if (cur_trans->aborted) {
|
2012-05-20 21:42:19 +08:00
|
|
|
spin_unlock(&fs_info->trans_lock);
|
2012-03-02 00:24:58 +08:00
|
|
|
return cur_trans->aborted;
|
2012-04-03 00:31:37 +08:00
|
|
|
}
|
2011-04-12 05:25:13 +08:00
|
|
|
atomic_inc(&cur_trans->use_count);
|
2011-04-12 03:45:29 +08:00
|
|
|
atomic_inc(&cur_trans->num_writers);
|
2007-08-11 04:22:09 +08:00
|
|
|
cur_trans->num_joined++;
|
2012-05-20 21:42:19 +08:00
|
|
|
spin_unlock(&fs_info->trans_lock);
|
2011-04-12 05:25:13 +08:00
|
|
|
return 0;
|
2007-03-23 03:59:16 +08:00
|
|
|
}
|
2012-05-20 21:42:19 +08:00
|
|
|
spin_unlock(&fs_info->trans_lock);
|
2011-04-12 05:25:13 +08:00
|
|
|
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
/*
|
|
|
|
* If we are ATTACH, we just want to catch the current transaction,
|
|
|
|
* and commit it. If there is no transaction, just return ENOENT.
|
|
|
|
*/
|
|
|
|
if (type == TRANS_ATTACH)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
|
|
|
|
if (!cur_trans)
|
|
|
|
return -ENOMEM;
|
2011-11-06 16:26:19 +08:00
|
|
|
|
2012-05-20 21:42:19 +08:00
|
|
|
spin_lock(&fs_info->trans_lock);
|
|
|
|
if (fs_info->running_transaction) {
|
2011-11-06 16:26:19 +08:00
|
|
|
/*
|
|
|
|
* someone started a transaction after we unlocked. Make sure
|
|
|
|
* to redo the trans_no_join checks above
|
|
|
|
*/
|
2011-04-12 05:25:13 +08:00
|
|
|
kmem_cache_free(btrfs_transaction_cachep, cur_trans);
|
2012-05-20 21:42:19 +08:00
|
|
|
cur_trans = fs_info->running_transaction;
|
2011-11-06 16:26:19 +08:00
|
|
|
goto loop;
|
2012-06-19 18:30:11 +08:00
|
|
|
} else if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
|
|
|
|
spin_unlock(&fs_info->trans_lock);
|
2012-06-01 03:52:43 +08:00
|
|
|
kmem_cache_free(btrfs_transaction_cachep, cur_trans);
|
|
|
|
return -EROFS;
|
2007-03-23 03:59:16 +08:00
|
|
|
}
|
2011-11-06 16:26:19 +08:00
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
atomic_set(&cur_trans->num_writers, 1);
|
|
|
|
cur_trans->num_joined = 0;
|
|
|
|
init_waitqueue_head(&cur_trans->writer_wait);
|
|
|
|
init_waitqueue_head(&cur_trans->commit_wait);
|
|
|
|
cur_trans->in_commit = 0;
|
|
|
|
cur_trans->blocked = 0;
|
|
|
|
/*
|
|
|
|
* One for this trans handle, one so it will live on until we
|
|
|
|
* commit the transaction.
|
|
|
|
*/
|
|
|
|
atomic_set(&cur_trans->use_count, 2);
|
|
|
|
cur_trans->commit_done = 0;
|
|
|
|
cur_trans->start_time = get_seconds();
|
|
|
|
|
|
|
|
cur_trans->delayed_refs.root = RB_ROOT;
|
|
|
|
cur_trans->delayed_refs.num_entries = 0;
|
|
|
|
cur_trans->delayed_refs.num_heads_ready = 0;
|
|
|
|
cur_trans->delayed_refs.num_heads = 0;
|
|
|
|
cur_trans->delayed_refs.flushing = 0;
|
|
|
|
cur_trans->delayed_refs.run_delayed_start = 0;
|
2012-05-20 21:43:53 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* although the tree mod log is per file system and not per transaction,
|
|
|
|
* the log must never go across transaction boundaries.
|
|
|
|
*/
|
|
|
|
smp_mb();
|
2012-11-03 18:58:34 +08:00
|
|
|
if (!list_empty(&fs_info->tree_mod_seq_list))
|
|
|
|
WARN(1, KERN_ERR "btrfs: tree_mod_seq_list not empty when "
|
2012-05-20 21:43:53 +08:00
|
|
|
"creating a fresh transaction\n");
|
2012-11-03 18:58:34 +08:00
|
|
|
if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log))
|
|
|
|
WARN(1, KERN_ERR "btrfs: tree_mod_log rb tree not empty when "
|
2012-05-20 21:43:53 +08:00
|
|
|
"creating a fresh transaction\n");
|
|
|
|
atomic_set(&fs_info->tree_mod_seq, 0);
|
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock_init(&cur_trans->commit_lock);
|
|
|
|
spin_lock_init(&cur_trans->delayed_refs.lock);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&cur_trans->pending_snapshots);
|
2012-05-20 21:42:19 +08:00
|
|
|
list_add_tail(&cur_trans->list, &fs_info->trans_list);
|
2011-04-12 05:25:13 +08:00
|
|
|
extent_io_tree_init(&cur_trans->dirty_pages,
|
2012-05-20 21:42:19 +08:00
|
|
|
fs_info->btree_inode->i_mapping);
|
|
|
|
fs_info->generation++;
|
|
|
|
cur_trans->transid = fs_info->generation;
|
|
|
|
fs_info->running_transaction = cur_trans;
|
2012-03-02 00:24:58 +08:00
|
|
|
cur_trans->aborted = 0;
|
2012-05-20 21:42:19 +08:00
|
|
|
spin_unlock(&fs_info->trans_lock);
|
2007-08-11 04:22:09 +08:00
|
|
|
|
2007-03-23 03:59:16 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08:00
|
|
|
/*
|
2009-01-06 10:25:51 +08: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-30 03:18:18 +08:00
|
|
|
*/
|
2011-06-14 08:00:16 +08:00
|
|
|
static int record_root_in_trans(struct btrfs_trans_handle *trans,
|
2011-04-12 05:25:13 +08:00
|
|
|
struct btrfs_root *root)
|
2007-08-08 04:15:09 +08: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 22:45:14 +08:00
|
|
|
if (root->ref_cows && root->last_trans < trans->transid) {
|
2007-08-08 04:15:09 +08: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 22:45:14 +08:00
|
|
|
WARN_ON(root->commit_root != root->node);
|
|
|
|
|
2011-06-14 08:00:16 +08:00
|
|
|
/*
|
|
|
|
* see below for in_trans_setup usage rules
|
|
|
|
* we have the reloc mutex held now, so there
|
|
|
|
* is only one writer in this function
|
|
|
|
*/
|
|
|
|
root->in_trans_setup = 1;
|
|
|
|
|
|
|
|
/* make sure readers find in_trans_setup before
|
|
|
|
* they find our root->last_trans update
|
|
|
|
*/
|
|
|
|
smp_wmb();
|
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&root->fs_info->fs_roots_radix_lock);
|
|
|
|
if (root->last_trans == trans->transid) {
|
|
|
|
spin_unlock(&root->fs_info->fs_roots_radix_lock);
|
|
|
|
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 22:45:14 +08:00
|
|
|
radix_tree_tag_set(&root->fs_info->fs_roots_radix,
|
|
|
|
(unsigned long)root->root_key.objectid,
|
|
|
|
BTRFS_ROOT_TRANS_TAG);
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&root->fs_info->fs_roots_radix_lock);
|
2011-06-14 08:00:16 +08:00
|
|
|
root->last_trans = trans->transid;
|
|
|
|
|
|
|
|
/* this is pretty tricky. We don't want to
|
|
|
|
* take the relocation lock in btrfs_record_root_in_trans
|
|
|
|
* unless we're really doing the first setup for this root in
|
|
|
|
* this transaction.
|
|
|
|
*
|
|
|
|
* Normally we'd use root->last_trans as a flag to decide
|
|
|
|
* if we want to take the expensive mutex.
|
|
|
|
*
|
|
|
|
* But, we have to set root->last_trans before we
|
|
|
|
* init the relocation root, otherwise, we trip over warnings
|
|
|
|
* in ctree.c. The solution used here is to flag ourselves
|
|
|
|
* with root->in_trans_setup. When this is 1, we're still
|
|
|
|
* fixing up the reloc trees and everyone must wait.
|
|
|
|
*
|
|
|
|
* When this is zero, they can trust root->last_trans and fly
|
|
|
|
* through btrfs_record_root_in_trans without having to take the
|
|
|
|
* lock. smp_wmb() makes sure that all the writes above are
|
|
|
|
* done before we pop in the zero below
|
|
|
|
*/
|
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 22:45:14 +08:00
|
|
|
btrfs_init_reloc_root(trans, root);
|
2011-06-14 08:00:16 +08:00
|
|
|
smp_wmb();
|
|
|
|
root->in_trans_setup = 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 22:45:14 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2008-07-31 04:29:20 +08:00
|
|
|
|
2011-06-14 08:00:16 +08:00
|
|
|
|
|
|
|
int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
if (!root->ref_cows)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* see record_root_in_trans for comments about in_trans_setup usage
|
|
|
|
* and barriers
|
|
|
|
*/
|
|
|
|
smp_rmb();
|
|
|
|
if (root->last_trans == trans->transid &&
|
|
|
|
!root->in_trans_setup)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
mutex_lock(&root->fs_info->reloc_mutex);
|
|
|
|
record_root_in_trans(trans, root);
|
|
|
|
mutex_unlock(&root->fs_info->reloc_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08: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 22:48:37 +08:00
|
|
|
static void wait_current_trans(struct btrfs_root *root)
|
2007-03-23 03:59:16 +08:00
|
|
|
{
|
2008-07-18 00:54:14 +08:00
|
|
|
struct btrfs_transaction *cur_trans;
|
2007-03-23 03:59:16 +08:00
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&root->fs_info->trans_lock);
|
2008-07-18 00:54:14 +08:00
|
|
|
cur_trans = root->fs_info->running_transaction;
|
2008-07-31 22:48:37 +08:00
|
|
|
if (cur_trans && cur_trans->blocked) {
|
2011-04-12 03:45:29 +08:00
|
|
|
atomic_inc(&cur_trans->use_count);
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
2011-07-14 11:17:00 +08:00
|
|
|
|
|
|
|
wait_event(root->fs_info->transaction_wait,
|
|
|
|
!cur_trans->blocked);
|
2008-07-18 00:54:14 +08:00
|
|
|
put_transaction(cur_trans);
|
2011-04-12 05:25:13 +08:00
|
|
|
} else {
|
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
2008-07-18 00:54:14 +08:00
|
|
|
}
|
2008-07-31 22:48:37 +08:00
|
|
|
}
|
|
|
|
|
2010-05-16 22:48:46 +08:00
|
|
|
static int may_wait_transaction(struct btrfs_root *root, int type)
|
|
|
|
{
|
2011-04-12 05:25:13 +08:00
|
|
|
if (root->fs_info->log_root_recovering)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (type == TRANS_USERSPACE)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (type == TRANS_START &&
|
|
|
|
!atomic_read(&root->fs_info->open_ioctl_trans))
|
2010-05-16 22:48:46 +08:00
|
|
|
return 1;
|
2011-04-12 05:25:13 +08:00
|
|
|
|
2010-05-16 22:48:46 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Btrfs: improve the noflush reservation
In some places(such as: evicting inode), we just can not flush the reserved
space of delalloc, flushing the delayed directory index and delayed inode
is OK, but we don't try to flush those things and just go back when there is
no enough space to be reserved. This patch fixes this problem.
We defined 3 types of the flush operations: NO_FLUSH, FLUSH_LIMIT and FLUSH_ALL.
If we can in the transaction, we should not flush anything, or the deadlock
would happen, so use NO_FLUSH. If we flushing the reserved space of delalloc
would cause deadlock, use FLUSH_LIMIT. In the other cases, FLUSH_ALL is used,
and we will flush all things.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2012-10-16 19:33:38 +08:00
|
|
|
static struct btrfs_trans_handle *
|
|
|
|
start_transaction(struct btrfs_root *root, u64 num_items, int type,
|
|
|
|
enum btrfs_reserve_flush_enum flush)
|
2008-07-31 22:48:37 +08:00
|
|
|
{
|
2010-05-16 22:48:46 +08:00
|
|
|
struct btrfs_trans_handle *h;
|
|
|
|
struct btrfs_transaction *cur_trans;
|
2011-06-08 03:07:51 +08:00
|
|
|
u64 num_bytes = 0;
|
2008-07-31 22:48:37 +08:00
|
|
|
int ret;
|
2011-09-14 21:44:05 +08:00
|
|
|
u64 qgroup_reserved = 0;
|
2011-01-06 19:30:25 +08:00
|
|
|
|
|
|
|
if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
|
|
|
|
return ERR_PTR(-EROFS);
|
2011-04-14 03:15:59 +08:00
|
|
|
|
|
|
|
if (current->journal_info) {
|
|
|
|
WARN_ON(type != TRANS_JOIN && type != TRANS_JOIN_NOLOCK);
|
|
|
|
h = current->journal_info;
|
|
|
|
h->use_count++;
|
2012-11-01 15:32:18 +08:00
|
|
|
WARN_ON(h->use_count > 2);
|
2011-04-14 03:15:59 +08:00
|
|
|
h->orig_rsv = h->block_rsv;
|
|
|
|
h->block_rsv = NULL;
|
|
|
|
goto got_it;
|
|
|
|
}
|
2011-06-08 03:07:51 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Do the reservation before we join the transaction so we can do all
|
|
|
|
* the appropriate flushing if need be.
|
|
|
|
*/
|
|
|
|
if (num_items > 0 && root != root->fs_info->chunk_root) {
|
2011-09-14 21:44:05 +08:00
|
|
|
if (root->fs_info->quota_enabled &&
|
|
|
|
is_fstree(root->root_key.objectid)) {
|
|
|
|
qgroup_reserved = num_items * root->leafsize;
|
|
|
|
ret = btrfs_qgroup_reserve(root, qgroup_reserved);
|
|
|
|
if (ret)
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
|
|
|
|
2011-06-08 03:07:51 +08:00
|
|
|
num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
|
Btrfs: improve the noflush reservation
In some places(such as: evicting inode), we just can not flush the reserved
space of delalloc, flushing the delayed directory index and delayed inode
is OK, but we don't try to flush those things and just go back when there is
no enough space to be reserved. This patch fixes this problem.
We defined 3 types of the flush operations: NO_FLUSH, FLUSH_LIMIT and FLUSH_ALL.
If we can in the transaction, we should not flush anything, or the deadlock
would happen, so use NO_FLUSH. If we flushing the reserved space of delalloc
would cause deadlock, use FLUSH_LIMIT. In the other cases, FLUSH_ALL is used,
and we will flush all things.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2012-10-16 19:33:38 +08:00
|
|
|
ret = btrfs_block_rsv_add(root,
|
|
|
|
&root->fs_info->trans_block_rsv,
|
|
|
|
num_bytes, flush);
|
2011-06-08 03:07:51 +08:00
|
|
|
if (ret)
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
2010-05-16 22:48:46 +08:00
|
|
|
again:
|
|
|
|
h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
|
|
|
|
if (!h)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2008-07-31 22:48:37 +08:00
|
|
|
|
2012-09-14 23:22:38 +08:00
|
|
|
/*
|
|
|
|
* If we are JOIN_NOLOCK we're already committing a transaction and
|
|
|
|
* waiting on this guy, so we don't need to do the sb_start_intwrite
|
|
|
|
* because we're already holding a ref. We need this because we could
|
|
|
|
* have raced in and did an fsync() on a file which can kick a commit
|
|
|
|
* and then we deadlock with somebody doing a freeze.
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
*
|
|
|
|
* If we are ATTACH, it means we just want to catch the current
|
|
|
|
* transaction and commit it, so we needn't do sb_start_intwrite().
|
2012-09-14 23:22:38 +08:00
|
|
|
*/
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
if (type < TRANS_JOIN_NOLOCK)
|
2012-09-14 22:34:40 +08:00
|
|
|
sb_start_intwrite(root->fs_info->sb);
|
2012-06-12 22:20:45 +08:00
|
|
|
|
2010-05-16 22:48:46 +08:00
|
|
|
if (may_wait_transaction(root, type))
|
2008-07-31 22:48:37 +08:00
|
|
|
wait_current_trans(root);
|
2010-05-16 22:48:46 +08:00
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
do {
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
ret = join_transaction(root, type);
|
2011-04-12 05:25:13 +08:00
|
|
|
if (ret == -EBUSY)
|
|
|
|
wait_current_trans(root);
|
|
|
|
} while (ret == -EBUSY);
|
|
|
|
|
2011-03-23 16:14:16 +08:00
|
|
|
if (ret < 0) {
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
/* We must get the transaction if we are JOIN_NOLOCK. */
|
|
|
|
BUG_ON(type == TRANS_JOIN_NOLOCK);
|
|
|
|
|
|
|
|
if (type < TRANS_JOIN_NOLOCK)
|
|
|
|
sb_end_intwrite(root->fs_info->sb);
|
2011-04-03 20:31:28 +08:00
|
|
|
kmem_cache_free(btrfs_trans_handle_cachep, h);
|
2011-03-23 16:14:16 +08:00
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
2007-04-09 22:42:37 +08:00
|
|
|
|
2010-05-16 22:48:46 +08:00
|
|
|
cur_trans = root->fs_info->running_transaction;
|
|
|
|
|
|
|
|
h->transid = cur_trans->transid;
|
|
|
|
h->transaction = cur_trans;
|
2007-03-23 03:59:16 +08:00
|
|
|
h->blocks_used = 0;
|
2010-05-16 22:48:46 +08:00
|
|
|
h->bytes_reserved = 0;
|
2011-09-13 17:40:09 +08:00
|
|
|
h->root = root;
|
2009-03-13 22:10:06 +08:00
|
|
|
h->delayed_ref_updates = 0;
|
2011-04-14 03:15:59 +08:00
|
|
|
h->use_count = 1;
|
2012-06-27 04:13:18 +08:00
|
|
|
h->adding_csums = 0;
|
2010-05-16 22:46:25 +08:00
|
|
|
h->block_rsv = NULL;
|
2011-04-14 03:15:59 +08:00
|
|
|
h->orig_rsv = NULL;
|
2012-03-02 00:24:58 +08:00
|
|
|
h->aborted = 0;
|
2011-09-14 21:44:05 +08:00
|
|
|
h->qgroup_reserved = qgroup_reserved;
|
2012-06-29 00:03:02 +08:00
|
|
|
h->delayed_ref_elem.seq = 0;
|
2012-09-20 15:51:59 +08:00
|
|
|
h->type = type;
|
2012-06-29 00:03:02 +08:00
|
|
|
INIT_LIST_HEAD(&h->qgroup_ref_list);
|
2012-09-12 04:57:25 +08:00
|
|
|
INIT_LIST_HEAD(&h->new_bgs);
|
2009-03-13 08:12:45 +08:00
|
|
|
|
2010-05-16 22:48:46 +08:00
|
|
|
smp_mb();
|
|
|
|
if (cur_trans->blocked && may_wait_transaction(root, type)) {
|
|
|
|
btrfs_commit_transaction(h, root);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
|
2011-06-08 03:07:51 +08:00
|
|
|
if (num_bytes) {
|
2012-01-10 23:31:31 +08:00
|
|
|
trace_btrfs_space_reservation(root->fs_info, "transaction",
|
2012-03-29 21:57:44 +08:00
|
|
|
h->transid, num_bytes, 1);
|
2011-06-08 03:07:51 +08:00
|
|
|
h->block_rsv = &root->fs_info->trans_block_rsv;
|
|
|
|
h->bytes_reserved = num_bytes;
|
2010-05-16 22:48:46 +08:00
|
|
|
}
|
2009-09-12 04:12:44 +08:00
|
|
|
|
2011-04-14 03:15:59 +08:00
|
|
|
got_it:
|
2011-04-12 05:25:13 +08:00
|
|
|
btrfs_record_root_in_trans(h, root);
|
2010-05-16 22:48:46 +08:00
|
|
|
|
|
|
|
if (!current->journal_info && type != TRANS_USERSPACE)
|
|
|
|
current->journal_info = h;
|
2007-03-23 03:59:16 +08:00
|
|
|
return h;
|
|
|
|
}
|
|
|
|
|
2008-07-18 00:54:14 +08:00
|
|
|
struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
|
2010-05-16 22:48:46 +08:00
|
|
|
int num_items)
|
2008-07-18 00:54:14 +08:00
|
|
|
{
|
Btrfs: improve the noflush reservation
In some places(such as: evicting inode), we just can not flush the reserved
space of delalloc, flushing the delayed directory index and delayed inode
is OK, but we don't try to flush those things and just go back when there is
no enough space to be reserved. This patch fixes this problem.
We defined 3 types of the flush operations: NO_FLUSH, FLUSH_LIMIT and FLUSH_ALL.
If we can in the transaction, we should not flush anything, or the deadlock
would happen, so use NO_FLUSH. If we flushing the reserved space of delalloc
would cause deadlock, use FLUSH_LIMIT. In the other cases, FLUSH_ALL is used,
and we will flush all things.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2012-10-16 19:33:38 +08:00
|
|
|
return start_transaction(root, num_items, TRANS_START,
|
|
|
|
BTRFS_RESERVE_FLUSH_ALL);
|
2008-07-18 00:54:14 +08:00
|
|
|
}
|
Btrfs: fix corrupted metadata in the snapshot
When we delete a inode, we will remove all the delayed items including delayed
inode update, and then truncate all the relative metadata. If there is lots of
metadata, we will end the current transaction, and start a new transaction to
truncate the left metadata. In this way, we will leave a inode item that its
link counter is > 0, and also may leave some directory index items in fs/file tree
after the current transaction ends. In other words, the metadata in this fs/file tree
is inconsistent. If we create a snapshot for this tree now, we will find a inode with
corrupted metadata in the new snapshot, and we won't continue to drop the left metadata,
because its link counter is not 0.
We fix this problem by updating the inode item before the current transaction ends.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-07 15:43:32 +08:00
|
|
|
|
Btrfs: improve the noflush reservation
In some places(such as: evicting inode), we just can not flush the reserved
space of delalloc, flushing the delayed directory index and delayed inode
is OK, but we don't try to flush those things and just go back when there is
no enough space to be reserved. This patch fixes this problem.
We defined 3 types of the flush operations: NO_FLUSH, FLUSH_LIMIT and FLUSH_ALL.
If we can in the transaction, we should not flush anything, or the deadlock
would happen, so use NO_FLUSH. If we flushing the reserved space of delalloc
would cause deadlock, use FLUSH_LIMIT. In the other cases, FLUSH_ALL is used,
and we will flush all things.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2012-10-16 19:33:38 +08:00
|
|
|
struct btrfs_trans_handle *btrfs_start_transaction_lflush(
|
Btrfs: fix corrupted metadata in the snapshot
When we delete a inode, we will remove all the delayed items including delayed
inode update, and then truncate all the relative metadata. If there is lots of
metadata, we will end the current transaction, and start a new transaction to
truncate the left metadata. In this way, we will leave a inode item that its
link counter is > 0, and also may leave some directory index items in fs/file tree
after the current transaction ends. In other words, the metadata in this fs/file tree
is inconsistent. If we create a snapshot for this tree now, we will find a inode with
corrupted metadata in the new snapshot, and we won't continue to drop the left metadata,
because its link counter is not 0.
We fix this problem by updating the inode item before the current transaction ends.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-07 15:43:32 +08:00
|
|
|
struct btrfs_root *root, int num_items)
|
|
|
|
{
|
Btrfs: improve the noflush reservation
In some places(such as: evicting inode), we just can not flush the reserved
space of delalloc, flushing the delayed directory index and delayed inode
is OK, but we don't try to flush those things and just go back when there is
no enough space to be reserved. This patch fixes this problem.
We defined 3 types of the flush operations: NO_FLUSH, FLUSH_LIMIT and FLUSH_ALL.
If we can in the transaction, we should not flush anything, or the deadlock
would happen, so use NO_FLUSH. If we flushing the reserved space of delalloc
would cause deadlock, use FLUSH_LIMIT. In the other cases, FLUSH_ALL is used,
and we will flush all things.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2012-10-16 19:33:38 +08:00
|
|
|
return start_transaction(root, num_items, TRANS_START,
|
|
|
|
BTRFS_RESERVE_FLUSH_LIMIT);
|
Btrfs: fix corrupted metadata in the snapshot
When we delete a inode, we will remove all the delayed items including delayed
inode update, and then truncate all the relative metadata. If there is lots of
metadata, we will end the current transaction, and start a new transaction to
truncate the left metadata. In this way, we will leave a inode item that its
link counter is > 0, and also may leave some directory index items in fs/file tree
after the current transaction ends. In other words, the metadata in this fs/file tree
is inconsistent. If we create a snapshot for this tree now, we will find a inode with
corrupted metadata in the new snapshot, and we won't continue to drop the left metadata,
because its link counter is not 0.
We fix this problem by updating the inode item before the current transaction ends.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-07 15:43:32 +08:00
|
|
|
}
|
|
|
|
|
2011-04-14 00:54:33 +08:00
|
|
|
struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
|
2008-07-18 00:54:14 +08:00
|
|
|
{
|
Btrfs: fix corrupted metadata in the snapshot
When we delete a inode, we will remove all the delayed items including delayed
inode update, and then truncate all the relative metadata. If there is lots of
metadata, we will end the current transaction, and start a new transaction to
truncate the left metadata. In this way, we will leave a inode item that its
link counter is > 0, and also may leave some directory index items in fs/file tree
after the current transaction ends. In other words, the metadata in this fs/file tree
is inconsistent. If we create a snapshot for this tree now, we will find a inode with
corrupted metadata in the new snapshot, and we won't continue to drop the left metadata,
because its link counter is not 0.
We fix this problem by updating the inode item before the current transaction ends.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-07 15:43:32 +08:00
|
|
|
return start_transaction(root, 0, TRANS_JOIN, 0);
|
2008-07-18 00:54:14 +08:00
|
|
|
}
|
|
|
|
|
2011-04-14 00:54:33 +08:00
|
|
|
struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
|
2010-06-22 02:48:16 +08:00
|
|
|
{
|
Btrfs: fix corrupted metadata in the snapshot
When we delete a inode, we will remove all the delayed items including delayed
inode update, and then truncate all the relative metadata. If there is lots of
metadata, we will end the current transaction, and start a new transaction to
truncate the left metadata. In this way, we will leave a inode item that its
link counter is > 0, and also may leave some directory index items in fs/file tree
after the current transaction ends. In other words, the metadata in this fs/file tree
is inconsistent. If we create a snapshot for this tree now, we will find a inode with
corrupted metadata in the new snapshot, and we won't continue to drop the left metadata,
because its link counter is not 0.
We fix this problem by updating the inode item before the current transaction ends.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-07 15:43:32 +08:00
|
|
|
return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 0);
|
2010-06-22 02:48:16 +08:00
|
|
|
}
|
|
|
|
|
2011-04-14 00:54:33 +08:00
|
|
|
struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
|
2008-08-04 22:41:27 +08:00
|
|
|
{
|
Btrfs: fix corrupted metadata in the snapshot
When we delete a inode, we will remove all the delayed items including delayed
inode update, and then truncate all the relative metadata. If there is lots of
metadata, we will end the current transaction, and start a new transaction to
truncate the left metadata. In this way, we will leave a inode item that its
link counter is > 0, and also may leave some directory index items in fs/file tree
after the current transaction ends. In other words, the metadata in this fs/file tree
is inconsistent. If we create a snapshot for this tree now, we will find a inode with
corrupted metadata in the new snapshot, and we won't continue to drop the left metadata,
because its link counter is not 0.
We fix this problem by updating the inode item before the current transaction ends.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-07 15:43:32 +08:00
|
|
|
return start_transaction(root, 0, TRANS_USERSPACE, 0);
|
2008-08-04 22:41:27 +08:00
|
|
|
}
|
|
|
|
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root)
|
2012-09-14 22:34:40 +08:00
|
|
|
{
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
return start_transaction(root, 0, TRANS_ATTACH, 0);
|
2012-09-14 22:34:40 +08:00
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08:00
|
|
|
/* wait for a transaction commit to be fully complete */
|
2011-07-14 11:17:14 +08:00
|
|
|
static noinline void wait_for_commit(struct btrfs_root *root,
|
2008-06-26 04:01:31 +08:00
|
|
|
struct btrfs_transaction *commit)
|
|
|
|
{
|
2011-07-14 11:17:00 +08:00
|
|
|
wait_event(commit->commit_wait, commit->commit_done);
|
2008-06-26 04:01:31 +08:00
|
|
|
}
|
|
|
|
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
|
|
|
|
{
|
|
|
|
struct btrfs_transaction *cur_trans = NULL, *t;
|
2012-11-26 16:42:07 +08:00
|
|
|
int ret = 0;
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
|
|
|
|
if (transid) {
|
|
|
|
if (transid <= root->fs_info->last_trans_committed)
|
2011-04-12 05:25:13 +08:00
|
|
|
goto out;
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
|
2012-11-26 16:42:07 +08:00
|
|
|
ret = -EINVAL;
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
/* find specified transaction */
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&root->fs_info->trans_lock);
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
list_for_each_entry(t, &root->fs_info->trans_list, list) {
|
|
|
|
if (t->transid == transid) {
|
|
|
|
cur_trans = t;
|
2011-04-12 05:25:13 +08:00
|
|
|
atomic_inc(&cur_trans->use_count);
|
2012-11-26 16:42:07 +08:00
|
|
|
ret = 0;
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
break;
|
|
|
|
}
|
2012-11-26 16:42:07 +08:00
|
|
|
if (t->transid > transid) {
|
|
|
|
ret = 0;
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
break;
|
2012-11-26 16:42:07 +08:00
|
|
|
}
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
}
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
2012-11-26 16:42:07 +08:00
|
|
|
/* The specified transaction doesn't exist */
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
if (!cur_trans)
|
2012-11-26 16:42:07 +08:00
|
|
|
goto out;
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
} else {
|
|
|
|
/* find newest transaction that is committing | committed */
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&root->fs_info->trans_lock);
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
list_for_each_entry_reverse(t, &root->fs_info->trans_list,
|
|
|
|
list) {
|
|
|
|
if (t->in_commit) {
|
|
|
|
if (t->commit_done)
|
2011-06-09 22:15:17 +08:00
|
|
|
break;
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
cur_trans = t;
|
2011-04-12 05:25:13 +08:00
|
|
|
atomic_inc(&cur_trans->use_count);
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
if (!cur_trans)
|
2011-04-12 05:25:13 +08:00
|
|
|
goto out; /* nothing committing|committed */
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
wait_for_commit(root, cur_trans);
|
|
|
|
put_transaction(cur_trans);
|
2011-04-12 05:25:13 +08:00
|
|
|
out:
|
Btrfs: add START_SYNC, WAIT_SYNC ioctls
START_SYNC will start a sync/commit, but not wait for it to
complete. Any modification started after the ioctl returns is
guaranteed not to be included in the commit. If a non-NULL
pointer is passed, the transaction id will be returned to
userspace.
WAIT_SYNC will wait for any in-progress commit to complete. If a
transaction id is specified, the ioctl will block and then
return (success) when the specified transaction has committed.
If it has already committed when we call the ioctl, it returns
immediately. If the specified transaction doesn't exist, it
returns EINVAL.
If no transaction id is specified, WAIT_SYNC will wait for the
currently committing transaction to finish it's commit to disk.
If there is no currently committing transaction, it returns
success.
These ioctls are useful for applications which want to impose an
ordering on when fs modifications reach disk, but do not want to
wait for the full (slow) commit process to do so.
Picky callers can take the transid returned by START_SYNC and
feed it to WAIT_SYNC, and be certain to wait only as long as
necessary for the transaction _they_ started to reach disk.
Sloppy callers can START_SYNC and WAIT_SYNC without a transid,
and provided they didn't wait too long between the calls, they
will get the same result. However, if a second commit starts
before they call WAIT_SYNC, they may end up waiting longer for
it to commit as well. Even so, a START_SYNC+WAIT_SYNC still
guarantees that any operation completed before the START_SYNC
reaches disk.
Signed-off-by: Sage Weil <sage@newdream.net>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-10-30 03:41:32 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-31 22:48:37 +08:00
|
|
|
void btrfs_throttle(struct btrfs_root *root)
|
|
|
|
{
|
2011-04-12 05:25:13 +08:00
|
|
|
if (!atomic_read(&root->fs_info->open_ioctl_trans))
|
2008-08-04 22:41:27 +08:00
|
|
|
wait_current_trans(root);
|
2008-07-31 22:48:37 +08:00
|
|
|
}
|
|
|
|
|
2010-05-16 22:49:58 +08:00
|
|
|
static int should_end_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
int ret;
|
2011-10-19 00:15:48 +08:00
|
|
|
|
|
|
|
ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
|
2010-05-16 22:49:58 +08:00
|
|
|
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;
|
2012-03-02 00:24:58 +08:00
|
|
|
int err;
|
2010-05-16 22:49:58 +08:00
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
smp_mb();
|
2010-05-16 22:49:58 +08:00
|
|
|
if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
updates = trans->delayed_ref_updates;
|
|
|
|
trans->delayed_ref_updates = 0;
|
2012-03-02 00:24:58 +08:00
|
|
|
if (updates) {
|
|
|
|
err = btrfs_run_delayed_refs(trans, root, updates);
|
|
|
|
if (err) /* Error code will also eval true */
|
|
|
|
return err;
|
|
|
|
}
|
2010-05-16 22:49:58 +08:00
|
|
|
|
|
|
|
return should_end_transaction(trans, root);
|
|
|
|
}
|
|
|
|
|
2008-06-26 04:01:31 +08:00
|
|
|
static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
|
2012-09-20 15:51:59 +08:00
|
|
|
struct btrfs_root *root, int throttle)
|
2007-03-23 03:59:16 +08:00
|
|
|
{
|
2010-05-16 22:49:58 +08:00
|
|
|
struct btrfs_transaction *cur_trans = trans->transaction;
|
2008-07-30 04:15:18 +08:00
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
2009-03-13 22:17:05 +08:00
|
|
|
int count = 0;
|
2012-09-20 15:51:59 +08:00
|
|
|
int lock = (trans->type != TRANS_JOIN_NOLOCK);
|
2012-04-13 04:03:56 +08:00
|
|
|
int err = 0;
|
2009-03-13 22:17:05 +08:00
|
|
|
|
2011-04-14 03:15:59 +08:00
|
|
|
if (--trans->use_count) {
|
|
|
|
trans->block_rsv = trans->orig_rsv;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-29 00:04:55 +08:00
|
|
|
/*
|
|
|
|
* do the qgroup accounting as early as possible
|
|
|
|
*/
|
|
|
|
err = btrfs_delayed_refs_qgroup_accounting(trans, info);
|
|
|
|
|
2011-10-15 02:40:17 +08:00
|
|
|
btrfs_trans_release_metadata(trans, root);
|
2011-08-30 23:31:29 +08:00
|
|
|
trans->block_rsv = NULL;
|
2011-09-13 17:40:09 +08:00
|
|
|
/*
|
|
|
|
* the same root has to be passed to start_transaction and
|
|
|
|
* end_transaction. Subvolume quota depends on this.
|
|
|
|
*/
|
|
|
|
WARN_ON(trans->root != root);
|
2011-09-14 21:44:05 +08:00
|
|
|
|
|
|
|
if (trans->qgroup_reserved) {
|
|
|
|
btrfs_qgroup_free(root, trans->qgroup_reserved);
|
|
|
|
trans->qgroup_reserved = 0;
|
|
|
|
}
|
|
|
|
|
2012-09-12 04:57:25 +08:00
|
|
|
if (!list_empty(&trans->new_bgs))
|
|
|
|
btrfs_create_pending_block_groups(trans, root);
|
|
|
|
|
2012-01-07 04:23:57 +08:00
|
|
|
while (count < 2) {
|
2009-03-13 22:17:05 +08:00
|
|
|
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;
|
|
|
|
btrfs_run_delayed_refs(trans, root, cur);
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
count++;
|
2009-03-13 22:10:06 +08:00
|
|
|
}
|
2012-06-27 04:13:18 +08:00
|
|
|
btrfs_trans_release_metadata(trans, root);
|
|
|
|
trans->block_rsv = NULL;
|
2009-03-13 22:10:06 +08:00
|
|
|
|
2012-09-12 04:57:25 +08:00
|
|
|
if (!list_empty(&trans->new_bgs))
|
|
|
|
btrfs_create_pending_block_groups(trans, root);
|
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
|
|
|
|
should_end_transaction(trans, root)) {
|
2010-05-16 22:49:58 +08:00
|
|
|
trans->transaction->blocked = 1;
|
2011-04-12 05:25:13 +08:00
|
|
|
smp_wmb();
|
|
|
|
}
|
2010-05-16 22:49:58 +08:00
|
|
|
|
2010-06-22 02:48:16 +08:00
|
|
|
if (lock && cur_trans->blocked && !cur_trans->in_commit) {
|
2011-07-25 03:45:34 +08:00
|
|
|
if (throttle) {
|
|
|
|
/*
|
|
|
|
* We may race with somebody else here so end up having
|
|
|
|
* to call end_transaction on ourselves again, so inc
|
|
|
|
* our use_count.
|
|
|
|
*/
|
|
|
|
trans->use_count++;
|
2010-05-16 22:49:58 +08:00
|
|
|
return btrfs_commit_transaction(trans, root);
|
2011-07-25 03:45:34 +08:00
|
|
|
} else {
|
2010-05-16 22:49:58 +08:00
|
|
|
wake_up_process(info->transaction_kthread);
|
2011-07-25 03:45:34 +08:00
|
|
|
}
|
2010-05-16 22:49:58 +08:00
|
|
|
}
|
|
|
|
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
if (trans->type < TRANS_JOIN_NOLOCK)
|
2012-09-14 23:22:38 +08:00
|
|
|
sb_end_intwrite(root->fs_info->sb);
|
2012-09-05 22:08:30 +08:00
|
|
|
|
2010-05-16 22:49:58 +08:00
|
|
|
WARN_ON(cur_trans != info->running_transaction);
|
2011-04-12 03:45:29 +08:00
|
|
|
WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
|
|
|
|
atomic_dec(&cur_trans->num_writers);
|
2008-06-26 04:01:31 +08:00
|
|
|
|
2010-10-30 03:37:34 +08:00
|
|
|
smp_mb();
|
2007-03-23 03:59:16 +08:00
|
|
|
if (waitqueue_active(&cur_trans->writer_wait))
|
|
|
|
wake_up(&cur_trans->writer_wait);
|
|
|
|
put_transaction(cur_trans);
|
2009-09-12 04:12:44 +08:00
|
|
|
|
|
|
|
if (current->journal_info == trans)
|
|
|
|
current->journal_info = NULL;
|
2008-07-30 04:15:18 +08:00
|
|
|
|
2009-11-12 17:36:34 +08:00
|
|
|
if (throttle)
|
|
|
|
btrfs_run_delayed_iputs(root);
|
|
|
|
|
2012-03-02 00:24:58 +08:00
|
|
|
if (trans->aborted ||
|
|
|
|
root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
|
2012-04-13 04:03:56 +08:00
|
|
|
err = -EIO;
|
2012-03-02 00:24:58 +08:00
|
|
|
}
|
2012-06-29 00:04:55 +08:00
|
|
|
assert_qgroups_uptodate(trans);
|
2012-03-02 00:24:58 +08:00
|
|
|
|
2012-04-13 04:03:56 +08:00
|
|
|
memset(trans, 0, sizeof(*trans));
|
|
|
|
kmem_cache_free(btrfs_trans_handle_cachep, trans);
|
|
|
|
return err;
|
2007-03-23 03:59:16 +08:00
|
|
|
}
|
|
|
|
|
2008-06-26 04:01:31 +08:00
|
|
|
int btrfs_end_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
btrfs: implement delayed inode items operation
Changelog V5 -> V6:
- Fix oom when the memory load is high, by storing the delayed nodes into the
root's radix tree, and letting btrfs inodes go.
Changelog V4 -> V5:
- Fix the race on adding the delayed node to the inode, which is spotted by
Chris Mason.
- Merge Chris Mason's incremental patch into this patch.
- Fix deadlock between readdir() and memory fault, which is reported by
Itaru Kitayama.
Changelog V3 -> V4:
- Fix nested lock, which is reported by Itaru Kitayama, by updating space cache
inode in time.
Changelog V2 -> V3:
- Fix the race between the delayed worker and the task which does delayed items
balance, which is reported by Tsutomu Itoh.
- Modify the patch address David Sterba's comment.
- Fix the bug of the cpu recursion spinlock, reported by Chris Mason
Changelog V1 -> V2:
- break up the global rb-tree, use a list to manage the delayed nodes,
which is created for every directory and file, and used to manage the
delayed directory name index items and the delayed inode item.
- introduce a worker to deal with the delayed nodes.
Compare with Ext3/4, the performance of file creation and deletion on btrfs
is very poor. the reason is that btrfs must do a lot of b+ tree insertions,
such as inode item, directory name item, directory name index and so on.
If we can do some delayed b+ tree insertion or deletion, we can improve the
performance, so we made this patch which implemented delayed directory name
index insertion/deletion and delayed inode update.
Implementation:
- introduce a delayed root object into the filesystem, that use two lists to
manage the delayed nodes which are created for every file/directory.
One is used to manage all the delayed nodes that have delayed items. And the
other is used to manage the delayed nodes which is waiting to be dealt with
by the work thread.
- Every delayed node has two rb-tree, one is used to manage the directory name
index which is going to be inserted into b+ tree, and the other is used to
manage the directory name index which is going to be deleted from b+ tree.
- introduce a worker to deal with the delayed operation. This worker is used
to deal with the works of the delayed directory name index items insertion
and deletion and the delayed inode update.
When the delayed items is beyond the lower limit, we create works for some
delayed nodes and insert them into the work queue of the worker, and then
go back.
When the delayed items is beyond the upper bound, we create works for all
the delayed nodes that haven't been dealt with, and insert them into the work
queue of the worker, and then wait for that the untreated items is below some
threshold value.
- When we want to insert a directory name index into b+ tree, we just add the
information into the delayed inserting rb-tree.
And then we check the number of the delayed items and do delayed items
balance. (The balance policy is above.)
- When we want to delete a directory name index from the b+ tree, we search it
in the inserting rb-tree at first. If we look it up, just drop it. If not,
add the key of it into the delayed deleting rb-tree.
Similar to the delayed inserting rb-tree, we also check the number of the
delayed items and do delayed items balance.
(The same to inserting manipulation)
- When we want to update the metadata of some inode, we cached the data of the
inode into the delayed node. the worker will flush it into the b+ tree after
dealing with the delayed insertion and deletion.
- We will move the delayed node to the tail of the list after we access the
delayed node, By this way, we can cache more delayed items and merge more
inode updates.
- If we want to commit transaction, we will deal with all the delayed node.
- the delayed node will be freed when we free the btrfs inode.
- Before we log the inode items, we commit all the directory name index items
and the delayed inode update.
I did a quick test by the benchmark tool[1] and found we can improve the
performance of file creation by ~15%, and file deletion by ~20%.
Before applying this patch:
Create files:
Total files: 50000
Total time: 1.096108
Average time: 0.000022
Delete files:
Total files: 50000
Total time: 1.510403
Average time: 0.000030
After applying this patch:
Create files:
Total files: 50000
Total time: 0.932899
Average time: 0.000019
Delete files:
Total files: 50000
Total time: 1.215732
Average time: 0.000024
[1] http://marc.info/?l=linux-btrfs&m=128212635122920&q=p3
Many thanks for Kitayama-san's help!
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Reviewed-by: David Sterba <dave@jikos.cz>
Tested-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Tested-by: Itaru Kitayama <kitayama@cl.bb4u.ne.jp>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-04-22 18:12:22 +08:00
|
|
|
int ret;
|
|
|
|
|
2012-09-20 15:51:59 +08:00
|
|
|
ret = __btrfs_end_transaction(trans, root, 0);
|
btrfs: implement delayed inode items operation
Changelog V5 -> V6:
- Fix oom when the memory load is high, by storing the delayed nodes into the
root's radix tree, and letting btrfs inodes go.
Changelog V4 -> V5:
- Fix the race on adding the delayed node to the inode, which is spotted by
Chris Mason.
- Merge Chris Mason's incremental patch into this patch.
- Fix deadlock between readdir() and memory fault, which is reported by
Itaru Kitayama.
Changelog V3 -> V4:
- Fix nested lock, which is reported by Itaru Kitayama, by updating space cache
inode in time.
Changelog V2 -> V3:
- Fix the race between the delayed worker and the task which does delayed items
balance, which is reported by Tsutomu Itoh.
- Modify the patch address David Sterba's comment.
- Fix the bug of the cpu recursion spinlock, reported by Chris Mason
Changelog V1 -> V2:
- break up the global rb-tree, use a list to manage the delayed nodes,
which is created for every directory and file, and used to manage the
delayed directory name index items and the delayed inode item.
- introduce a worker to deal with the delayed nodes.
Compare with Ext3/4, the performance of file creation and deletion on btrfs
is very poor. the reason is that btrfs must do a lot of b+ tree insertions,
such as inode item, directory name item, directory name index and so on.
If we can do some delayed b+ tree insertion or deletion, we can improve the
performance, so we made this patch which implemented delayed directory name
index insertion/deletion and delayed inode update.
Implementation:
- introduce a delayed root object into the filesystem, that use two lists to
manage the delayed nodes which are created for every file/directory.
One is used to manage all the delayed nodes that have delayed items. And the
other is used to manage the delayed nodes which is waiting to be dealt with
by the work thread.
- Every delayed node has two rb-tree, one is used to manage the directory name
index which is going to be inserted into b+ tree, and the other is used to
manage the directory name index which is going to be deleted from b+ tree.
- introduce a worker to deal with the delayed operation. This worker is used
to deal with the works of the delayed directory name index items insertion
and deletion and the delayed inode update.
When the delayed items is beyond the lower limit, we create works for some
delayed nodes and insert them into the work queue of the worker, and then
go back.
When the delayed items is beyond the upper bound, we create works for all
the delayed nodes that haven't been dealt with, and insert them into the work
queue of the worker, and then wait for that the untreated items is below some
threshold value.
- When we want to insert a directory name index into b+ tree, we just add the
information into the delayed inserting rb-tree.
And then we check the number of the delayed items and do delayed items
balance. (The balance policy is above.)
- When we want to delete a directory name index from the b+ tree, we search it
in the inserting rb-tree at first. If we look it up, just drop it. If not,
add the key of it into the delayed deleting rb-tree.
Similar to the delayed inserting rb-tree, we also check the number of the
delayed items and do delayed items balance.
(The same to inserting manipulation)
- When we want to update the metadata of some inode, we cached the data of the
inode into the delayed node. the worker will flush it into the b+ tree after
dealing with the delayed insertion and deletion.
- We will move the delayed node to the tail of the list after we access the
delayed node, By this way, we can cache more delayed items and merge more
inode updates.
- If we want to commit transaction, we will deal with all the delayed node.
- the delayed node will be freed when we free the btrfs inode.
- Before we log the inode items, we commit all the directory name index items
and the delayed inode update.
I did a quick test by the benchmark tool[1] and found we can improve the
performance of file creation by ~15%, and file deletion by ~20%.
Before applying this patch:
Create files:
Total files: 50000
Total time: 1.096108
Average time: 0.000022
Delete files:
Total files: 50000
Total time: 1.510403
Average time: 0.000030
After applying this patch:
Create files:
Total files: 50000
Total time: 0.932899
Average time: 0.000019
Delete files:
Total files: 50000
Total time: 1.215732
Average time: 0.000024
[1] http://marc.info/?l=linux-btrfs&m=128212635122920&q=p3
Many thanks for Kitayama-san's help!
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Reviewed-by: David Sterba <dave@jikos.cz>
Tested-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Tested-by: Itaru Kitayama <kitayama@cl.bb4u.ne.jp>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-04-22 18:12:22 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
return 0;
|
2008-06-26 04:01:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
btrfs: implement delayed inode items operation
Changelog V5 -> V6:
- Fix oom when the memory load is high, by storing the delayed nodes into the
root's radix tree, and letting btrfs inodes go.
Changelog V4 -> V5:
- Fix the race on adding the delayed node to the inode, which is spotted by
Chris Mason.
- Merge Chris Mason's incremental patch into this patch.
- Fix deadlock between readdir() and memory fault, which is reported by
Itaru Kitayama.
Changelog V3 -> V4:
- Fix nested lock, which is reported by Itaru Kitayama, by updating space cache
inode in time.
Changelog V2 -> V3:
- Fix the race between the delayed worker and the task which does delayed items
balance, which is reported by Tsutomu Itoh.
- Modify the patch address David Sterba's comment.
- Fix the bug of the cpu recursion spinlock, reported by Chris Mason
Changelog V1 -> V2:
- break up the global rb-tree, use a list to manage the delayed nodes,
which is created for every directory and file, and used to manage the
delayed directory name index items and the delayed inode item.
- introduce a worker to deal with the delayed nodes.
Compare with Ext3/4, the performance of file creation and deletion on btrfs
is very poor. the reason is that btrfs must do a lot of b+ tree insertions,
such as inode item, directory name item, directory name index and so on.
If we can do some delayed b+ tree insertion or deletion, we can improve the
performance, so we made this patch which implemented delayed directory name
index insertion/deletion and delayed inode update.
Implementation:
- introduce a delayed root object into the filesystem, that use two lists to
manage the delayed nodes which are created for every file/directory.
One is used to manage all the delayed nodes that have delayed items. And the
other is used to manage the delayed nodes which is waiting to be dealt with
by the work thread.
- Every delayed node has two rb-tree, one is used to manage the directory name
index which is going to be inserted into b+ tree, and the other is used to
manage the directory name index which is going to be deleted from b+ tree.
- introduce a worker to deal with the delayed operation. This worker is used
to deal with the works of the delayed directory name index items insertion
and deletion and the delayed inode update.
When the delayed items is beyond the lower limit, we create works for some
delayed nodes and insert them into the work queue of the worker, and then
go back.
When the delayed items is beyond the upper bound, we create works for all
the delayed nodes that haven't been dealt with, and insert them into the work
queue of the worker, and then wait for that the untreated items is below some
threshold value.
- When we want to insert a directory name index into b+ tree, we just add the
information into the delayed inserting rb-tree.
And then we check the number of the delayed items and do delayed items
balance. (The balance policy is above.)
- When we want to delete a directory name index from the b+ tree, we search it
in the inserting rb-tree at first. If we look it up, just drop it. If not,
add the key of it into the delayed deleting rb-tree.
Similar to the delayed inserting rb-tree, we also check the number of the
delayed items and do delayed items balance.
(The same to inserting manipulation)
- When we want to update the metadata of some inode, we cached the data of the
inode into the delayed node. the worker will flush it into the b+ tree after
dealing with the delayed insertion and deletion.
- We will move the delayed node to the tail of the list after we access the
delayed node, By this way, we can cache more delayed items and merge more
inode updates.
- If we want to commit transaction, we will deal with all the delayed node.
- the delayed node will be freed when we free the btrfs inode.
- Before we log the inode items, we commit all the directory name index items
and the delayed inode update.
I did a quick test by the benchmark tool[1] and found we can improve the
performance of file creation by ~15%, and file deletion by ~20%.
Before applying this patch:
Create files:
Total files: 50000
Total time: 1.096108
Average time: 0.000022
Delete files:
Total files: 50000
Total time: 1.510403
Average time: 0.000030
After applying this patch:
Create files:
Total files: 50000
Total time: 0.932899
Average time: 0.000019
Delete files:
Total files: 50000
Total time: 1.215732
Average time: 0.000024
[1] http://marc.info/?l=linux-btrfs&m=128212635122920&q=p3
Many thanks for Kitayama-san's help!
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Reviewed-by: David Sterba <dave@jikos.cz>
Tested-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Tested-by: Itaru Kitayama <kitayama@cl.bb4u.ne.jp>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-04-22 18:12:22 +08:00
|
|
|
int ret;
|
|
|
|
|
2012-09-20 15:51:59 +08:00
|
|
|
ret = __btrfs_end_transaction(trans, root, 1);
|
btrfs: implement delayed inode items operation
Changelog V5 -> V6:
- Fix oom when the memory load is high, by storing the delayed nodes into the
root's radix tree, and letting btrfs inodes go.
Changelog V4 -> V5:
- Fix the race on adding the delayed node to the inode, which is spotted by
Chris Mason.
- Merge Chris Mason's incremental patch into this patch.
- Fix deadlock between readdir() and memory fault, which is reported by
Itaru Kitayama.
Changelog V3 -> V4:
- Fix nested lock, which is reported by Itaru Kitayama, by updating space cache
inode in time.
Changelog V2 -> V3:
- Fix the race between the delayed worker and the task which does delayed items
balance, which is reported by Tsutomu Itoh.
- Modify the patch address David Sterba's comment.
- Fix the bug of the cpu recursion spinlock, reported by Chris Mason
Changelog V1 -> V2:
- break up the global rb-tree, use a list to manage the delayed nodes,
which is created for every directory and file, and used to manage the
delayed directory name index items and the delayed inode item.
- introduce a worker to deal with the delayed nodes.
Compare with Ext3/4, the performance of file creation and deletion on btrfs
is very poor. the reason is that btrfs must do a lot of b+ tree insertions,
such as inode item, directory name item, directory name index and so on.
If we can do some delayed b+ tree insertion or deletion, we can improve the
performance, so we made this patch which implemented delayed directory name
index insertion/deletion and delayed inode update.
Implementation:
- introduce a delayed root object into the filesystem, that use two lists to
manage the delayed nodes which are created for every file/directory.
One is used to manage all the delayed nodes that have delayed items. And the
other is used to manage the delayed nodes which is waiting to be dealt with
by the work thread.
- Every delayed node has two rb-tree, one is used to manage the directory name
index which is going to be inserted into b+ tree, and the other is used to
manage the directory name index which is going to be deleted from b+ tree.
- introduce a worker to deal with the delayed operation. This worker is used
to deal with the works of the delayed directory name index items insertion
and deletion and the delayed inode update.
When the delayed items is beyond the lower limit, we create works for some
delayed nodes and insert them into the work queue of the worker, and then
go back.
When the delayed items is beyond the upper bound, we create works for all
the delayed nodes that haven't been dealt with, and insert them into the work
queue of the worker, and then wait for that the untreated items is below some
threshold value.
- When we want to insert a directory name index into b+ tree, we just add the
information into the delayed inserting rb-tree.
And then we check the number of the delayed items and do delayed items
balance. (The balance policy is above.)
- When we want to delete a directory name index from the b+ tree, we search it
in the inserting rb-tree at first. If we look it up, just drop it. If not,
add the key of it into the delayed deleting rb-tree.
Similar to the delayed inserting rb-tree, we also check the number of the
delayed items and do delayed items balance.
(The same to inserting manipulation)
- When we want to update the metadata of some inode, we cached the data of the
inode into the delayed node. the worker will flush it into the b+ tree after
dealing with the delayed insertion and deletion.
- We will move the delayed node to the tail of the list after we access the
delayed node, By this way, we can cache more delayed items and merge more
inode updates.
- If we want to commit transaction, we will deal with all the delayed node.
- the delayed node will be freed when we free the btrfs inode.
- Before we log the inode items, we commit all the directory name index items
and the delayed inode update.
I did a quick test by the benchmark tool[1] and found we can improve the
performance of file creation by ~15%, and file deletion by ~20%.
Before applying this patch:
Create files:
Total files: 50000
Total time: 1.096108
Average time: 0.000022
Delete files:
Total files: 50000
Total time: 1.510403
Average time: 0.000030
After applying this patch:
Create files:
Total files: 50000
Total time: 0.932899
Average time: 0.000019
Delete files:
Total files: 50000
Total time: 1.215732
Average time: 0.000024
[1] http://marc.info/?l=linux-btrfs&m=128212635122920&q=p3
Many thanks for Kitayama-san's help!
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Reviewed-by: David Sterba <dave@jikos.cz>
Tested-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Tested-by: Itaru Kitayama <kitayama@cl.bb4u.ne.jp>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-04-22 18:12:22 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
2012-09-20 15:51:59 +08:00
|
|
|
return __btrfs_end_transaction(trans, root, 1);
|
2008-06-26 04:01:31 +08:00
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08: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-14 01:29:19 +08:00
|
|
|
* those extents are sent to disk but does not wait on them
|
2008-09-30 03:18:18 +08:00
|
|
|
*/
|
2009-10-14 01:29:19 +08:00
|
|
|
int btrfs_write_marked_extents(struct btrfs_root *root,
|
2009-11-12 17:33:26 +08:00
|
|
|
struct extent_io_tree *dirty_pages, int mark)
|
2007-03-23 03:59:16 +08:00
|
|
|
{
|
2008-08-16 03:34:15 +08:00
|
|
|
int err = 0;
|
2007-04-28 21:29:35 +08:00
|
|
|
int werr = 0;
|
2011-09-27 01:58:47 +08:00
|
|
|
struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
|
2012-09-28 05:07:30 +08:00
|
|
|
struct extent_state *cached_state = NULL;
|
2008-08-16 03:34:15 +08:00
|
|
|
u64 start = 0;
|
2007-10-16 04:14:19 +08:00
|
|
|
u64 end;
|
2007-04-28 21:29:35 +08:00
|
|
|
|
2011-09-27 01:58:47 +08:00
|
|
|
while (!find_first_extent_bit(dirty_pages, start, &start, &end,
|
2012-09-28 05:07:30 +08:00
|
|
|
mark, &cached_state)) {
|
|
|
|
convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT,
|
|
|
|
mark, &cached_state, GFP_NOFS);
|
|
|
|
cached_state = NULL;
|
2011-09-27 01:58:47 +08:00
|
|
|
err = filemap_fdatawrite_range(mapping, start, end);
|
|
|
|
if (err)
|
|
|
|
werr = err;
|
|
|
|
cond_resched();
|
|
|
|
start = end + 1;
|
2007-04-28 21:29:35 +08:00
|
|
|
}
|
2009-10-14 01:29:19 +08: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 17:33:26 +08:00
|
|
|
struct extent_io_tree *dirty_pages, int mark)
|
2009-10-14 01:29:19 +08:00
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
int werr = 0;
|
2011-09-27 01:58:47 +08:00
|
|
|
struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
|
2012-09-28 05:07:30 +08:00
|
|
|
struct extent_state *cached_state = NULL;
|
2009-10-14 01:29:19 +08:00
|
|
|
u64 start = 0;
|
|
|
|
u64 end;
|
2008-08-16 03:34:15 +08:00
|
|
|
|
2011-09-27 01:58:47 +08:00
|
|
|
while (!find_first_extent_bit(dirty_pages, start, &start, &end,
|
2012-09-28 05:07:30 +08:00
|
|
|
EXTENT_NEED_WAIT, &cached_state)) {
|
|
|
|
clear_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT,
|
|
|
|
0, 0, &cached_state, GFP_NOFS);
|
2011-09-27 01:58:47 +08:00
|
|
|
err = filemap_fdatawait_range(mapping, start, end);
|
|
|
|
if (err)
|
|
|
|
werr = err;
|
|
|
|
cond_resched();
|
|
|
|
start = end + 1;
|
2008-08-16 03:34:15 +08:00
|
|
|
}
|
2007-04-28 21:29:35 +08:00
|
|
|
if (err)
|
|
|
|
werr = err;
|
|
|
|
return werr;
|
2007-03-23 03:59:16 +08:00
|
|
|
}
|
|
|
|
|
2009-10-14 01:29:19 +08: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 17:33:26 +08:00
|
|
|
struct extent_io_tree *dirty_pages, int mark)
|
2009-10-14 01:29:19 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int ret2;
|
|
|
|
|
2009-11-12 17:33:26 +08:00
|
|
|
ret = btrfs_write_marked_extents(root, dirty_pages, mark);
|
|
|
|
ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
|
2011-11-05 00:29:37 +08:00
|
|
|
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (ret2)
|
|
|
|
return ret2;
|
|
|
|
return 0;
|
2009-10-14 01:29:19 +08:00
|
|
|
}
|
|
|
|
|
2008-09-12 04:17:57 +08: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 17:33:26 +08:00
|
|
|
&trans->transaction->dirty_pages,
|
|
|
|
EXTENT_DIRTY);
|
2008-09-12 04:17:57 +08:00
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08: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-25 03:01:56 +08:00
|
|
|
static int update_cowonly_root(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
2007-03-23 03:59:16 +08:00
|
|
|
{
|
|
|
|
int ret;
|
2008-03-25 03:01:56 +08:00
|
|
|
u64 old_root_bytenr;
|
2009-11-12 17:36:50 +08:00
|
|
|
u64 old_root_used;
|
2008-03-25 03:01:56 +08:00
|
|
|
struct btrfs_root *tree_root = root->fs_info->tree_root;
|
2007-03-23 03:59:16 +08:00
|
|
|
|
2009-11-12 17:36:50 +08:00
|
|
|
old_root_used = btrfs_root_used(&root->root_item);
|
2008-03-25 03:01:56 +08:00
|
|
|
btrfs_write_dirty_block_groups(trans, root);
|
2009-03-13 22:10:06 +08:00
|
|
|
|
2009-01-06 10:25:51 +08:00
|
|
|
while (1) {
|
2008-03-25 03:01:56 +08:00
|
|
|
old_root_bytenr = btrfs_root_bytenr(&root->root_item);
|
2009-11-12 17:36:50 +08:00
|
|
|
if (old_root_bytenr == root->node->start &&
|
|
|
|
old_root_used == btrfs_root_used(&root->root_item))
|
2007-03-23 03:59:16 +08:00
|
|
|
break;
|
2008-10-30 23:23:27 +08: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 22:45:14 +08:00
|
|
|
btrfs_set_root_node(&root->root_item, root->node);
|
2007-03-23 03:59:16 +08:00
|
|
|
ret = btrfs_update_root(trans, tree_root,
|
2008-03-25 03:01:56 +08:00
|
|
|
&root->root_key,
|
|
|
|
&root->root_item);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2009-03-13 22:10:06 +08:00
|
|
|
|
2009-11-12 17:36:50 +08:00
|
|
|
old_root_used = btrfs_root_used(&root->root_item);
|
2009-07-22 22:07:05 +08:00
|
|
|
ret = btrfs_write_dirty_block_groups(trans, root);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-03-25 03:01:56 +08:00
|
|
|
}
|
2009-07-30 21:40:40 +08:00
|
|
|
|
|
|
|
if (root != root->fs_info->extent_root)
|
|
|
|
switch_commit_root(root);
|
|
|
|
|
2008-03-25 03:01:56 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08:00
|
|
|
/*
|
|
|
|
* update all the cowonly tree roots on disk
|
2012-03-02 00:24:58 +08:00
|
|
|
*
|
|
|
|
* The error handling in this function may not be obvious. Any of the
|
|
|
|
* failures will cause the file system to go offline. We still need
|
|
|
|
* to clean up the delayed refs.
|
2008-09-30 03:18:18 +08: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 22:45:14 +08:00
|
|
|
static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
2008-03-25 03:01:56 +08:00
|
|
|
{
|
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
|
|
struct list_head *next;
|
2008-10-30 02:49:05 +08:00
|
|
|
struct extent_buffer *eb;
|
2009-03-13 22:10:06 +08:00
|
|
|
int ret;
|
2008-10-30 02:49:05 +08:00
|
|
|
|
2009-03-13 22:10:06 +08:00
|
|
|
ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-10-30 23:23:27 +08:00
|
|
|
|
2008-10-30 02:49:05 +08:00
|
|
|
eb = btrfs_lock_root_node(fs_info->tree_root);
|
2012-03-02 00:24:58 +08:00
|
|
|
ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,
|
|
|
|
0, &eb);
|
2008-10-30 02:49:05 +08:00
|
|
|
btrfs_tree_unlock(eb);
|
|
|
|
free_extent_buffer(eb);
|
2008-03-25 03:01:56 +08:00
|
|
|
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2009-03-13 22:10:06 +08:00
|
|
|
ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-10-30 23:23:27 +08:00
|
|
|
|
2012-05-25 22:06:10 +08:00
|
|
|
ret = btrfs_run_dev_stats(trans, root->fs_info);
|
2012-11-06 20:15:27 +08:00
|
|
|
WARN_ON(ret);
|
|
|
|
ret = btrfs_run_dev_replace(trans, root->fs_info);
|
|
|
|
WARN_ON(ret);
|
2012-05-25 22:06:10 +08:00
|
|
|
|
2012-06-14 22:37:44 +08:00
|
|
|
ret = btrfs_run_qgroups(trans, root->fs_info);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
|
|
|
/* run_qgroups might have added some more refs */
|
|
|
|
ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
2009-01-06 10:25:51 +08:00
|
|
|
while (!list_empty(&fs_info->dirty_cowonly_roots)) {
|
2008-03-25 03:01:56 +08:00
|
|
|
next = fs_info->dirty_cowonly_roots.next;
|
|
|
|
list_del_init(next);
|
|
|
|
root = list_entry(next, struct btrfs_root, dirty_list);
|
2008-10-30 23:23:27 +08:00
|
|
|
|
2012-03-02 00:24:58 +08:00
|
|
|
ret = update_cowonly_root(trans, root);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2007-03-23 03:59:16 +08:00
|
|
|
}
|
2009-07-30 21:40:40 +08:00
|
|
|
|
|
|
|
down_write(&fs_info->extent_commit_sem);
|
|
|
|
switch_commit_root(fs_info->extent_root);
|
|
|
|
up_write(&fs_info->extent_commit_sem);
|
|
|
|
|
2012-11-06 20:15:27 +08:00
|
|
|
btrfs_after_dev_replace_commit(fs_info);
|
|
|
|
|
2007-03-23 03:59:16 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08: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 22:45:14 +08:00
|
|
|
int btrfs_add_dead_root(struct btrfs_root *root)
|
2007-06-23 02:16:25 +08:00
|
|
|
{
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&root->fs_info->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 22:45:14 +08:00
|
|
|
list_add(&root->root_list, &root->fs_info->dead_roots);
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
2007-06-23 02:16:25 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08: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 22:45:14 +08:00
|
|
|
* update all the cowonly tree roots on disk
|
2008-09-30 03:18:18 +08: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 22:45:14 +08:00
|
|
|
static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
2007-04-09 22:42:37 +08: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 22:45:14 +08:00
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
2007-04-09 22:42:37 +08:00
|
|
|
int i;
|
|
|
|
int ret;
|
2007-06-23 02:16:25 +08:00
|
|
|
int err = 0;
|
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&fs_info->fs_roots_radix_lock);
|
2009-01-06 10:25:51 +08: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 22:45:14 +08:00
|
|
|
ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
|
|
|
|
(void **)gang, 0,
|
2007-04-09 22:42:37 +08: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 22:45:14 +08:00
|
|
|
radix_tree_tag_clear(&fs_info->fs_roots_radix,
|
|
|
|
(unsigned long)root->root_key.objectid,
|
|
|
|
BTRFS_ROOT_TRANS_TAG);
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&fs_info->fs_roots_radix_lock);
|
2008-07-29 03:32:19 +08:00
|
|
|
|
2008-09-06 04:13:11 +08: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 22:45:14 +08:00
|
|
|
btrfs_update_reloc_root(trans, root);
|
2010-05-16 22:49:58 +08:00
|
|
|
btrfs_orphan_commit_root(trans, root);
|
2008-07-31 04:29:20 +08:00
|
|
|
|
2011-04-20 10:33:24 +08:00
|
|
|
btrfs_save_ino_cache(root, trans);
|
|
|
|
|
2011-11-15 09:48:06 +08:00
|
|
|
/* see comments in should_cow_block() */
|
|
|
|
root->force_cow = 0;
|
|
|
|
smp_wmb();
|
|
|
|
|
2009-06-16 08:01:02 +08:00
|
|
|
if (root->commit_root != root->node) {
|
Btrfs: Cache free inode numbers in memory
Currently btrfs stores the highest objectid of the fs tree, and it always
returns (highest+1) inode number when we create a file, so inode numbers
won't be reclaimed when we delete files, so we'll run out of inode numbers
as we keep create/delete files in 32bits machines.
This fixes it, and it works similarly to how we cache free space in block
cgroups.
We start a kernel thread to read the file tree. By scanning inode items,
we know which chunks of inode numbers are free, and we cache them in
an rb-tree.
Because we are searching the commit root, we have to carefully handle the
cross-transaction case.
The rb-tree is a hybrid extent+bitmap tree, so if we have too many small
chunks of inode numbers, we'll use bitmaps. Initially we allow 16K ram
of extents, and a bitmap will be used if we exceed this threshold. The
extents threshold is adjusted in runtime.
Signed-off-by: Li Zefan <lizf@cn.fujitsu.com>
2011-04-20 10:06:11 +08:00
|
|
|
mutex_lock(&root->fs_commit_mutex);
|
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 09:29:25 +08:00
|
|
|
switch_commit_root(root);
|
Btrfs: Cache free inode numbers in memory
Currently btrfs stores the highest objectid of the fs tree, and it always
returns (highest+1) inode number when we create a file, so inode numbers
won't be reclaimed when we delete files, so we'll run out of inode numbers
as we keep create/delete files in 32bits machines.
This fixes it, and it works similarly to how we cache free space in block
cgroups.
We start a kernel thread to read the file tree. By scanning inode items,
we know which chunks of inode numbers are free, and we cache them in
an rb-tree.
Because we are searching the commit root, we have to carefully handle the
cross-transaction case.
The rb-tree is a hybrid extent+bitmap tree, so if we have too many small
chunks of inode numbers, we'll use bitmaps. Initially we allow 16K ram
of extents, and a bitmap will be used if we exceed this threshold. The
extents threshold is adjusted in runtime.
Signed-off-by: Li Zefan <lizf@cn.fujitsu.com>
2011-04-20 10:06:11 +08:00
|
|
|
btrfs_unpin_free_ino(root);
|
|
|
|
mutex_unlock(&root->fs_commit_mutex);
|
|
|
|
|
2009-06-16 08:01:02 +08: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 22:45:14 +08:00
|
|
|
|
|
|
|
err = btrfs_update_root(trans, fs_info->tree_root,
|
2007-04-09 22:42:37 +08:00
|
|
|
&root->root_key,
|
|
|
|
&root->root_item);
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&fs_info->fs_roots_radix_lock);
|
2007-06-23 02:16:25 +08:00
|
|
|
if (err)
|
|
|
|
break;
|
2007-04-09 22:42:37 +08:00
|
|
|
}
|
|
|
|
}
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&fs_info->fs_roots_radix_lock);
|
2007-06-23 02:16:25 +08:00
|
|
|
return err;
|
2007-04-09 22:42:37 +08:00
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08: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-11 02:06:19 +08: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 22:49:58 +08:00
|
|
|
int ret;
|
2007-08-11 02:06:19 +08:00
|
|
|
|
2010-05-16 22:49:58 +08:00
|
|
|
if (xchg(&root->defrag_running, 1))
|
2007-08-11 02:06:19 +08:00
|
|
|
return 0;
|
2010-05-16 22:49:58 +08:00
|
|
|
|
2007-10-16 04:17:34 +08:00
|
|
|
while (1) {
|
2010-05-16 22:49:58 +08:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
|
|
|
if (IS_ERR(trans))
|
|
|
|
return PTR_ERR(trans);
|
|
|
|
|
2007-08-11 02:06:19 +08:00
|
|
|
ret = btrfs_defrag_leaves(trans, root, cacheonly);
|
2010-05-16 22:49:58 +08:00
|
|
|
|
2007-08-11 02:06:19 +08:00
|
|
|
btrfs_end_transaction(trans, root);
|
2012-11-14 22:34:34 +08:00
|
|
|
btrfs_btree_balance_dirty(info->tree_root);
|
2007-08-11 02:06:19 +08:00
|
|
|
cond_resched();
|
|
|
|
|
2011-06-01 00:07:27 +08:00
|
|
|
if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
|
2007-08-11 02:06:19 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
root->defrag_running = 0;
|
2010-05-16 22:49:58 +08:00
|
|
|
return ret;
|
2007-08-11 02:06:19 +08:00
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08:00
|
|
|
/*
|
|
|
|
* new snapshots need to be created at a very specific time in the
|
|
|
|
* transaction commit. This does the actual creation
|
|
|
|
*/
|
2008-02-02 05:35:04 +08:00
|
|
|
static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
|
2008-01-09 04:46:30 +08:00
|
|
|
struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_pending_snapshot *pending)
|
|
|
|
{
|
|
|
|
struct btrfs_key key;
|
2008-02-02 05:35:04 +08:00
|
|
|
struct btrfs_root_item *new_root_item;
|
2008-01-09 04:46:30 +08:00
|
|
|
struct btrfs_root *tree_root = fs_info->tree_root;
|
|
|
|
struct btrfs_root *root = pending->root;
|
2010-03-16 01:27:13 +08:00
|
|
|
struct btrfs_root *parent_root;
|
2011-09-11 22:52:24 +08:00
|
|
|
struct btrfs_block_rsv *rsv;
|
2010-03-16 01:27:13 +08:00
|
|
|
struct inode *parent_inode;
|
2012-09-06 18:03:32 +08:00
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_dir_item *dir_item;
|
2010-11-20 17:48:00 +08:00
|
|
|
struct dentry *parent;
|
2010-05-16 22:48:46 +08:00
|
|
|
struct dentry *dentry;
|
2008-01-09 04:46:30 +08:00
|
|
|
struct extent_buffer *tmp;
|
2008-06-26 04:01:30 +08:00
|
|
|
struct extent_buffer *old;
|
2012-07-25 23:35:53 +08:00
|
|
|
struct timespec cur_time = CURRENT_TIME;
|
2008-01-09 04:46:30 +08:00
|
|
|
int ret;
|
2010-05-16 22:49:58 +08:00
|
|
|
u64 to_reserve = 0;
|
2010-03-16 01:27:13 +08:00
|
|
|
u64 index = 0;
|
2010-05-16 22:48:46 +08:00
|
|
|
u64 objectid;
|
2010-12-20 16:04:08 +08:00
|
|
|
u64 root_flags;
|
2012-07-25 23:35:53 +08:00
|
|
|
uuid_le new_uuid;
|
2008-01-09 04:46:30 +08:00
|
|
|
|
2012-09-06 18:03:32 +08:00
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path) {
|
|
|
|
ret = pending->error = -ENOMEM;
|
|
|
|
goto path_alloc_fail;
|
|
|
|
}
|
|
|
|
|
2008-02-02 05:35:04 +08:00
|
|
|
new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
|
|
|
|
if (!new_root_item) {
|
2012-03-02 00:24:58 +08:00
|
|
|
ret = pending->error = -ENOMEM;
|
2012-09-06 18:00:32 +08:00
|
|
|
goto root_item_alloc_fail;
|
2008-02-02 05:35:04 +08:00
|
|
|
}
|
2010-05-16 22:48:46 +08:00
|
|
|
|
Btrfs: Cache free inode numbers in memory
Currently btrfs stores the highest objectid of the fs tree, and it always
returns (highest+1) inode number when we create a file, so inode numbers
won't be reclaimed when we delete files, so we'll run out of inode numbers
as we keep create/delete files in 32bits machines.
This fixes it, and it works similarly to how we cache free space in block
cgroups.
We start a kernel thread to read the file tree. By scanning inode items,
we know which chunks of inode numbers are free, and we cache them in
an rb-tree.
Because we are searching the commit root, we have to carefully handle the
cross-transaction case.
The rb-tree is a hybrid extent+bitmap tree, so if we have too many small
chunks of inode numbers, we'll use bitmaps. Initially we allow 16K ram
of extents, and a bitmap will be used if we exceed this threshold. The
extents threshold is adjusted in runtime.
Signed-off-by: Li Zefan <lizf@cn.fujitsu.com>
2011-04-20 10:06:11 +08:00
|
|
|
ret = btrfs_find_free_objectid(tree_root, &objectid);
|
2010-05-16 22:48:46 +08:00
|
|
|
if (ret) {
|
|
|
|
pending->error = ret;
|
2012-09-06 18:00:32 +08:00
|
|
|
goto no_free_objectid;
|
2010-05-16 22:48:46 +08:00
|
|
|
}
|
2008-01-09 04:46:30 +08:00
|
|
|
|
2010-05-16 22:49:59 +08:00
|
|
|
btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
|
2010-05-16 22:49:58 +08:00
|
|
|
|
|
|
|
if (to_reserve > 0) {
|
Btrfs: improve the noflush reservation
In some places(such as: evicting inode), we just can not flush the reserved
space of delalloc, flushing the delayed directory index and delayed inode
is OK, but we don't try to flush those things and just go back when there is
no enough space to be reserved. This patch fixes this problem.
We defined 3 types of the flush operations: NO_FLUSH, FLUSH_LIMIT and FLUSH_ALL.
If we can in the transaction, we should not flush anything, or the deadlock
would happen, so use NO_FLUSH. If we flushing the reserved space of delalloc
would cause deadlock, use FLUSH_LIMIT. In the other cases, FLUSH_ALL is used,
and we will flush all things.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2012-10-16 19:33:38 +08:00
|
|
|
ret = btrfs_block_rsv_add(root, &pending->block_rsv,
|
|
|
|
to_reserve,
|
|
|
|
BTRFS_RESERVE_NO_FLUSH);
|
2010-05-16 22:49:58 +08:00
|
|
|
if (ret) {
|
|
|
|
pending->error = ret;
|
2012-09-06 18:00:32 +08:00
|
|
|
goto no_free_objectid;
|
2010-05-16 22:49:58 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-14 21:58:21 +08:00
|
|
|
ret = btrfs_qgroup_inherit(trans, fs_info, root->root_key.objectid,
|
|
|
|
objectid, pending->inherit);
|
|
|
|
if (ret) {
|
|
|
|
pending->error = ret;
|
2012-09-06 18:00:32 +08:00
|
|
|
goto no_free_objectid;
|
2011-09-14 21:58:21 +08:00
|
|
|
}
|
|
|
|
|
2008-01-09 04:46:30 +08:00
|
|
|
key.objectid = objectid;
|
2010-05-16 22:48:46 +08:00
|
|
|
key.offset = (u64)-1;
|
|
|
|
key.type = BTRFS_ROOT_ITEM_KEY;
|
2008-01-09 04:46:30 +08:00
|
|
|
|
2012-09-06 18:00:32 +08:00
|
|
|
rsv = trans->block_rsv;
|
2010-05-16 22:48:46 +08:00
|
|
|
trans->block_rsv = &pending->block_rsv;
|
2008-11-18 10:02:50 +08:00
|
|
|
|
2010-05-16 22:48:46 +08:00
|
|
|
dentry = pending->dentry;
|
2010-11-20 17:48:00 +08:00
|
|
|
parent = dget_parent(dentry);
|
|
|
|
parent_inode = parent->d_inode;
|
2010-05-16 22:48:46 +08:00
|
|
|
parent_root = BTRFS_I(parent_inode)->root;
|
2011-06-14 08:00:16 +08:00
|
|
|
record_root_in_trans(trans, parent_root);
|
2010-05-16 22:48:46 +08:00
|
|
|
|
2008-01-09 04:46:30 +08:00
|
|
|
/*
|
|
|
|
* insert the directory item
|
|
|
|
*/
|
2008-11-18 10:02:50 +08:00
|
|
|
ret = btrfs_set_inode_index(parent_inode, &index);
|
2012-03-02 00:24:58 +08:00
|
|
|
BUG_ON(ret); /* -ENOMEM */
|
2012-09-06 18:03:32 +08:00
|
|
|
|
|
|
|
/* check if there is a file/dir which has the same name. */
|
|
|
|
dir_item = btrfs_lookup_dir_item(NULL, parent_root, path,
|
|
|
|
btrfs_ino(parent_inode),
|
|
|
|
dentry->d_name.name,
|
|
|
|
dentry->d_name.len, 0);
|
|
|
|
if (dir_item != NULL && !IS_ERR(dir_item)) {
|
2012-02-20 21:40:56 +08:00
|
|
|
pending->error = -EEXIST;
|
|
|
|
goto fail;
|
2012-09-06 18:03:32 +08:00
|
|
|
} else if (IS_ERR(dir_item)) {
|
|
|
|
ret = PTR_ERR(dir_item);
|
2012-09-18 13:52:38 +08:00
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto fail;
|
2012-03-12 23:03:00 +08:00
|
|
|
}
|
2012-09-06 18:03:32 +08:00
|
|
|
btrfs_release_path(path);
|
2009-01-06 04:43:43 +08:00
|
|
|
|
2011-06-18 04:14:09 +08:00
|
|
|
/*
|
|
|
|
* pull in the delayed directory update
|
|
|
|
* and the delayed inode item
|
|
|
|
* otherwise we corrupt the FS during
|
|
|
|
* snapshot
|
|
|
|
*/
|
|
|
|
ret = btrfs_run_delayed_items(trans, root);
|
2012-09-18 13:52:38 +08:00
|
|
|
if (ret) { /* Transaction aborted */
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto fail;
|
|
|
|
}
|
2011-06-18 04:14:09 +08:00
|
|
|
|
2011-06-14 08:00:16 +08:00
|
|
|
record_root_in_trans(trans, root);
|
2010-03-16 01:27:13 +08:00
|
|
|
btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
|
|
|
|
memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
|
2011-03-28 10:01:25 +08:00
|
|
|
btrfs_check_and_init_root_item(new_root_item);
|
2010-03-16 01:27:13 +08:00
|
|
|
|
2010-12-20 16:04:08 +08:00
|
|
|
root_flags = btrfs_root_flags(new_root_item);
|
|
|
|
if (pending->readonly)
|
|
|
|
root_flags |= BTRFS_ROOT_SUBVOL_RDONLY;
|
|
|
|
else
|
|
|
|
root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY;
|
|
|
|
btrfs_set_root_flags(new_root_item, root_flags);
|
|
|
|
|
2012-07-25 23:35:53 +08:00
|
|
|
btrfs_set_root_generation_v2(new_root_item,
|
|
|
|
trans->transid);
|
|
|
|
uuid_le_gen(&new_uuid);
|
|
|
|
memcpy(new_root_item->uuid, new_uuid.b, BTRFS_UUID_SIZE);
|
|
|
|
memcpy(new_root_item->parent_uuid, root->root_item.uuid,
|
|
|
|
BTRFS_UUID_SIZE);
|
|
|
|
new_root_item->otime.sec = cpu_to_le64(cur_time.tv_sec);
|
2012-07-30 16:10:44 +08:00
|
|
|
new_root_item->otime.nsec = cpu_to_le32(cur_time.tv_nsec);
|
2012-07-25 23:35:53 +08:00
|
|
|
btrfs_set_root_otransid(new_root_item, trans->transid);
|
|
|
|
memset(&new_root_item->stime, 0, sizeof(new_root_item->stime));
|
|
|
|
memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime));
|
|
|
|
btrfs_set_root_stransid(new_root_item, 0);
|
|
|
|
btrfs_set_root_rtransid(new_root_item, 0);
|
|
|
|
|
2010-03-16 01:27:13 +08:00
|
|
|
old = btrfs_lock_root_node(root);
|
2012-03-02 00:24:58 +08:00
|
|
|
ret = btrfs_cow_block(trans, root, old, NULL, 0, &old);
|
2012-03-12 23:03:00 +08:00
|
|
|
if (ret) {
|
|
|
|
btrfs_tree_unlock(old);
|
|
|
|
free_extent_buffer(old);
|
2012-09-18 13:52:38 +08:00
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto fail;
|
2012-03-12 23:03:00 +08:00
|
|
|
}
|
2012-03-02 00:24:58 +08:00
|
|
|
|
2010-03-16 01:27:13 +08:00
|
|
|
btrfs_set_lock_blocking(old);
|
|
|
|
|
2012-03-02 00:24:58 +08:00
|
|
|
ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
|
2012-03-12 23:03:00 +08:00
|
|
|
/* clean up in any case */
|
2010-03-16 01:27:13 +08:00
|
|
|
btrfs_tree_unlock(old);
|
|
|
|
free_extent_buffer(old);
|
2012-09-18 13:52:38 +08:00
|
|
|
if (ret) {
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-03-16 01:27:13 +08:00
|
|
|
|
2011-11-15 09:48:06 +08:00
|
|
|
/* see comments in should_cow_block() */
|
|
|
|
root->force_cow = 1;
|
|
|
|
smp_wmb();
|
|
|
|
|
2010-03-16 01:27:13 +08:00
|
|
|
btrfs_set_root_node(new_root_item, tmp);
|
2010-05-16 22:48:46 +08: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-16 01:27:13 +08:00
|
|
|
btrfs_tree_unlock(tmp);
|
|
|
|
free_extent_buffer(tmp);
|
2012-09-18 13:52:38 +08:00
|
|
|
if (ret) {
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-03-16 01:27:13 +08:00
|
|
|
|
2010-05-16 22:48:46 +08:00
|
|
|
/*
|
|
|
|
* insert root back/forward references
|
|
|
|
*/
|
|
|
|
ret = btrfs_add_root_ref(trans, tree_root, objectid,
|
2008-11-18 09:37:39 +08:00
|
|
|
parent_root->root_key.objectid,
|
2011-04-20 10:31:50 +08:00
|
|
|
btrfs_ino(parent_inode), index,
|
2010-05-16 22:48:46 +08:00
|
|
|
dentry->d_name.name, dentry->d_name.len);
|
2012-09-18 13:52:38 +08:00
|
|
|
if (ret) {
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto fail;
|
|
|
|
}
|
2008-11-18 09:37:39 +08:00
|
|
|
|
2010-05-16 22:48:46 +08:00
|
|
|
key.offset = (u64)-1;
|
|
|
|
pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
|
2012-03-12 23:03:00 +08:00
|
|
|
if (IS_ERR(pending->snap)) {
|
|
|
|
ret = PTR_ERR(pending->snap);
|
2012-09-18 13:52:38 +08:00
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto fail;
|
2012-03-12 23:03:00 +08:00
|
|
|
}
|
2010-05-16 22:49:58 +08:00
|
|
|
|
2012-03-02 00:24:58 +08:00
|
|
|
ret = btrfs_reloc_post_snapshot(trans, pending);
|
2012-09-18 13:52:38 +08:00
|
|
|
if (ret) {
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto fail;
|
|
|
|
}
|
Btrfs: fix full backref problem when inserting shared block reference
If we create several snapshots at the same time, the following BUG_ON() will be
triggered.
kernel BUG at fs/btrfs/extent-tree.c:6047!
Steps to reproduce:
# mkfs.btrfs <partition>
# mount <partition> <mnt>
# cd <mnt>
# for ((i=0;i<2400;i++)); do touch long_name_to_make_tree_more_deep$i; done
# for ((i=0; i<4; i++))
> do
> mkdir $i
> for ((j=0; j<200; j++))
> do
> btrfs sub snap . $i/$j
> done &
> done
The reason is:
Before transaction commit, some operations changed the fs tree and new tree
blocks were allocated because of COW. We used the implicit non-shared back
reference for those newly allocated tree blocks because they were not shared by
two or more trees.
And then we created the first snapshot for the fs tree, according to the back
reference rules, we also used implicit back refs for the child tree blocks of
the root node of the fs tree, now those child nodes/leaves were shared by two
trees.
Then We didn't deal with the delayed references, and continued to change the fs
tree(created the second snapshot and inserted the dir item of the new snapshot
into the fs tree). According to the rules of the back reference, we added full
back refs for those tree blocks whose parents have be shared by two trees.
Now some newly allocated tree blocks had two types of the references.
As we know, the delayed reference system handles these delayed references from
back to front, and the full delayed reference is inserted after the implicit
ones. So when we dealt with the back references of those newly allocated tree
blocks, the full references was dealt with at first. And if the first reference
is a shared back reference and the tree block that the reference points to is
newly allocated, It would be considered as a tree block which is shared by two
or more trees when it is allocated and should be a full back reference not a
implicit one, the flag of its reference also should be set to FULL_BACKREF.
But in fact, it was a non-shared tree block with a implicit reference at
beginning, so it was not compulsory to set the flags to FULL_BACKREF. So BUG_ON
was triggered.
We have several methods to fix this bug:
1. deal with delayed references after the snapshot is created and before we
change the source tree of the snapshot. This is the easiest and safest way.
2. modify the sort method of the delayed reference tree, make the full delayed
references be inserted before the implicit ones. It is also very easy, but
I don't know if it will introduce some problems or not.
3. modify select_delayed_ref() and make it select the implicit delayed reference
at first. This way is not so good because it may wastes CPU time if we have
lots of delayed references.
4. set the flags to FULL_BACKREF, this method is a little complex comparing with
the 1st way.
I chose the 1st way to fix it.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-06 18:00:57 +08:00
|
|
|
|
|
|
|
ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
|
2012-09-18 13:52:38 +08:00
|
|
|
if (ret) {
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto fail;
|
|
|
|
}
|
2012-09-06 18:03:32 +08:00
|
|
|
|
|
|
|
ret = btrfs_insert_dir_item(trans, parent_root,
|
|
|
|
dentry->d_name.name, dentry->d_name.len,
|
|
|
|
parent_inode, &key,
|
|
|
|
BTRFS_FT_DIR, index);
|
|
|
|
/* We have check then name at the beginning, so it is impossible. */
|
2012-12-18 03:26:57 +08:00
|
|
|
BUG_ON(ret == -EEXIST || ret == -EOVERFLOW);
|
2012-09-18 13:52:38 +08:00
|
|
|
if (ret) {
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto fail;
|
|
|
|
}
|
2012-09-06 18:03:32 +08:00
|
|
|
|
|
|
|
btrfs_i_size_write(parent_inode, parent_inode->i_size +
|
|
|
|
dentry->d_name.len * 2);
|
|
|
|
parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
|
2012-10-23 03:43:12 +08:00
|
|
|
ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode);
|
2012-09-06 18:03:32 +08:00
|
|
|
if (ret)
|
2012-09-18 13:52:38 +08:00
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
2008-01-09 04:46:30 +08:00
|
|
|
fail:
|
2012-09-06 18:00:32 +08:00
|
|
|
dput(parent);
|
2011-09-11 22:52:24 +08:00
|
|
|
trans->block_rsv = rsv;
|
2012-09-06 18:00:32 +08:00
|
|
|
no_free_objectid:
|
|
|
|
kfree(new_root_item);
|
|
|
|
root_item_alloc_fail:
|
2012-09-06 18:03:32 +08:00
|
|
|
btrfs_free_path(path);
|
|
|
|
path_alloc_fail:
|
2010-05-16 22:48:46 +08:00
|
|
|
btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
|
2012-03-02 00:24:58 +08:00
|
|
|
return ret;
|
2008-01-09 04:46:30 +08:00
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08:00
|
|
|
/*
|
|
|
|
* create all the snapshots we've scheduled for creation
|
|
|
|
*/
|
2008-02-02 05:35:04 +08:00
|
|
|
static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info)
|
2008-11-18 10:02:50 +08:00
|
|
|
{
|
|
|
|
struct btrfs_pending_snapshot *pending;
|
|
|
|
struct list_head *head = &trans->transaction->pending_snapshots;
|
|
|
|
|
2012-02-20 21:40:56 +08:00
|
|
|
list_for_each_entry(pending, head, list)
|
|
|
|
create_pending_snapshot(trans, fs_info, pending);
|
2008-11-18 10:02:50 +08:00
|
|
|
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 22:45:14 +08:00
|
|
|
static void update_super_roots(struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
struct btrfs_root_item *root_item;
|
|
|
|
struct btrfs_super_block *super;
|
|
|
|
|
2011-04-13 21:41:04 +08:00
|
|
|
super = root->fs_info->super_copy;
|
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 22:45:14 +08:00
|
|
|
|
|
|
|
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;
|
2011-10-04 02:07:49 +08:00
|
|
|
if (btrfs_test_opt(root, SPACE_CACHE))
|
2010-06-22 02:48:16 +08:00
|
|
|
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 22:45:14 +08:00
|
|
|
}
|
|
|
|
|
2009-07-30 22:04:48 +08:00
|
|
|
int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&info->trans_lock);
|
2009-07-30 22:04:48 +08:00
|
|
|
if (info->running_transaction)
|
|
|
|
ret = info->running_transaction->in_commit;
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&info->trans_lock);
|
2009-07-30 22:04:48 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-05-16 22:49:58 +08:00
|
|
|
int btrfs_transaction_blocked(struct btrfs_fs_info *info)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&info->trans_lock);
|
2010-05-16 22:49:58 +08:00
|
|
|
if (info->running_transaction)
|
|
|
|
ret = info->running_transaction->blocked;
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&info->trans_lock);
|
2010-05-16 22:49:58 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-10-30 03:37:34 +08:00
|
|
|
/*
|
|
|
|
* wait for the current transaction commit to start and block subsequent
|
|
|
|
* transaction joins
|
|
|
|
*/
|
|
|
|
static void wait_current_trans_commit_start(struct btrfs_root *root,
|
|
|
|
struct btrfs_transaction *trans)
|
|
|
|
{
|
2011-07-14 11:17:00 +08:00
|
|
|
wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit);
|
2010-10-30 03:37:34 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* wait for the current transaction to start and then become unblocked.
|
|
|
|
* caller holds ref.
|
|
|
|
*/
|
|
|
|
static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root,
|
|
|
|
struct btrfs_transaction *trans)
|
|
|
|
{
|
2011-07-14 11:17:00 +08:00
|
|
|
wait_event(root->fs_info->transaction_wait,
|
|
|
|
trans->commit_done || (trans->in_commit && !trans->blocked));
|
2010-10-30 03:37:34 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* commit transactions asynchronously. once btrfs_commit_transaction_async
|
|
|
|
* returns, any subsequent transaction will not be allowed to join.
|
|
|
|
*/
|
|
|
|
struct btrfs_async_commit {
|
|
|
|
struct btrfs_trans_handle *newtrans;
|
|
|
|
struct btrfs_root *root;
|
|
|
|
struct delayed_work work;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void do_async_commit(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct btrfs_async_commit *ac =
|
|
|
|
container_of(work, struct btrfs_async_commit, work.work);
|
|
|
|
|
2012-08-31 06:26:15 +08:00
|
|
|
/*
|
|
|
|
* We've got freeze protection passed with the transaction.
|
|
|
|
* Tell lockdep about it.
|
|
|
|
*/
|
2012-11-26 16:41:29 +08:00
|
|
|
if (ac->newtrans->type < TRANS_JOIN_NOLOCK)
|
|
|
|
rwsem_acquire_read(
|
|
|
|
&ac->root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
|
|
|
|
0, 1, _THIS_IP_);
|
2012-08-31 06:26:15 +08:00
|
|
|
|
2012-08-31 06:26:16 +08:00
|
|
|
current->journal_info = ac->newtrans;
|
|
|
|
|
2010-10-30 03:37:34 +08:00
|
|
|
btrfs_commit_transaction(ac->newtrans, ac->root);
|
|
|
|
kfree(ac);
|
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
int wait_for_unblock)
|
|
|
|
{
|
|
|
|
struct btrfs_async_commit *ac;
|
|
|
|
struct btrfs_transaction *cur_trans;
|
|
|
|
|
|
|
|
ac = kmalloc(sizeof(*ac), GFP_NOFS);
|
2011-03-23 16:14:16 +08:00
|
|
|
if (!ac)
|
|
|
|
return -ENOMEM;
|
2010-10-30 03:37:34 +08:00
|
|
|
|
|
|
|
INIT_DELAYED_WORK(&ac->work, do_async_commit);
|
|
|
|
ac->root = root;
|
2011-04-14 00:54:33 +08:00
|
|
|
ac->newtrans = btrfs_join_transaction(root);
|
2011-01-25 10:51:38 +08:00
|
|
|
if (IS_ERR(ac->newtrans)) {
|
|
|
|
int err = PTR_ERR(ac->newtrans);
|
|
|
|
kfree(ac);
|
|
|
|
return err;
|
|
|
|
}
|
2010-10-30 03:37:34 +08:00
|
|
|
|
|
|
|
/* take transaction reference */
|
|
|
|
cur_trans = trans->transaction;
|
2011-04-12 03:45:29 +08:00
|
|
|
atomic_inc(&cur_trans->use_count);
|
2010-10-30 03:37:34 +08:00
|
|
|
|
|
|
|
btrfs_end_transaction(trans, root);
|
2012-08-31 06:26:15 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Tell lockdep we've released the freeze rwsem, since the
|
|
|
|
* async commit thread will be the one to unlock it.
|
|
|
|
*/
|
2012-11-26 16:41:29 +08:00
|
|
|
if (trans->type < TRANS_JOIN_NOLOCK)
|
|
|
|
rwsem_release(
|
|
|
|
&root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
|
|
|
|
1, _THIS_IP_);
|
2012-08-31 06:26:15 +08:00
|
|
|
|
2010-10-30 03:37:34 +08:00
|
|
|
schedule_delayed_work(&ac->work, 0);
|
|
|
|
|
|
|
|
/* wait for transaction to start and unblock */
|
|
|
|
if (wait_for_unblock)
|
|
|
|
wait_current_trans_commit_start_and_unblock(root, cur_trans);
|
|
|
|
else
|
|
|
|
wait_current_trans_commit_start(root, cur_trans);
|
|
|
|
|
2011-06-11 02:43:13 +08:00
|
|
|
if (current->journal_info == trans)
|
|
|
|
current->journal_info = NULL;
|
|
|
|
|
|
|
|
put_transaction(cur_trans);
|
2010-10-30 03:37:34 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-02 00:24:58 +08:00
|
|
|
|
|
|
|
static void cleanup_transaction(struct btrfs_trans_handle *trans,
|
2012-06-01 03:52:43 +08:00
|
|
|
struct btrfs_root *root, int err)
|
2012-03-02 00:24:58 +08:00
|
|
|
{
|
|
|
|
struct btrfs_transaction *cur_trans = trans->transaction;
|
|
|
|
|
|
|
|
WARN_ON(trans->use_count > 1);
|
|
|
|
|
2012-06-01 03:52:43 +08:00
|
|
|
btrfs_abort_transaction(trans, root, err);
|
|
|
|
|
2012-03-02 00:24:58 +08:00
|
|
|
spin_lock(&root->fs_info->trans_lock);
|
|
|
|
list_del_init(&cur_trans->list);
|
2012-06-01 03:49:57 +08:00
|
|
|
if (cur_trans == root->fs_info->running_transaction) {
|
|
|
|
root->fs_info->running_transaction = NULL;
|
|
|
|
root->fs_info->trans_no_join = 0;
|
|
|
|
}
|
2012-03-02 00:24:58 +08:00
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
|
|
|
|
|
|
|
btrfs_cleanup_one_transaction(trans->transaction, root);
|
|
|
|
|
|
|
|
put_transaction(cur_trans);
|
|
|
|
put_transaction(cur_trans);
|
|
|
|
|
|
|
|
trace_btrfs_transaction_commit(root);
|
|
|
|
|
|
|
|
btrfs_scrub_continue(root);
|
|
|
|
|
|
|
|
if (current->journal_info == trans)
|
|
|
|
current->journal_info = NULL;
|
|
|
|
|
|
|
|
kmem_cache_free(btrfs_trans_handle_cachep, trans);
|
|
|
|
}
|
|
|
|
|
2012-11-01 15:33:14 +08:00
|
|
|
static int btrfs_flush_all_pending_stuffs(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
|
|
|
|
int snap_pending = 0;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!flush_on_commit) {
|
|
|
|
spin_lock(&root->fs_info->trans_lock);
|
|
|
|
if (!list_empty(&trans->transaction->pending_snapshots))
|
|
|
|
snap_pending = 1;
|
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flush_on_commit || snap_pending) {
|
|
|
|
btrfs_start_delalloc_inodes(root, 1);
|
|
|
|
btrfs_wait_ordered_extents(root, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = btrfs_run_delayed_items(trans, root);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* running the delayed items may have added new refs. account
|
|
|
|
* them now so that they hinder processing of more delayed refs
|
|
|
|
* as little as possible.
|
|
|
|
*/
|
|
|
|
btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-30 03:37:34 +08:00
|
|
|
/*
|
|
|
|
* btrfs_transaction state sequence:
|
|
|
|
* in_commit = 0, blocked = 0 (initial)
|
|
|
|
* in_commit = 1, blocked = 1
|
|
|
|
* blocked = 0
|
|
|
|
* commit_done = 1
|
|
|
|
*/
|
2007-03-23 03:59:16 +08:00
|
|
|
int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
2007-08-11 04:22:09 +08:00
|
|
|
unsigned long joined = 0;
|
2012-03-02 00:24:58 +08:00
|
|
|
struct btrfs_transaction *cur_trans = trans->transaction;
|
2007-04-20 09:01:03 +08:00
|
|
|
struct btrfs_transaction *prev_trans = NULL;
|
2007-03-23 03:59:16 +08:00
|
|
|
DEFINE_WAIT(wait);
|
2012-10-25 17:31:03 +08:00
|
|
|
int ret;
|
2009-03-13 08:12:45 +08:00
|
|
|
int should_grow = 0;
|
|
|
|
unsigned long now = get_seconds();
|
2007-03-23 03:59:16 +08:00
|
|
|
|
2012-10-25 17:31:03 +08:00
|
|
|
ret = btrfs_run_ordered_operations(root, 0);
|
|
|
|
if (ret) {
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto cleanup_transaction;
|
|
|
|
}
|
2009-04-01 01:27:11 +08:00
|
|
|
|
2013-01-15 14:27:25 +08:00
|
|
|
/* Stop the commit early if ->aborted is set */
|
|
|
|
if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
|
2012-10-25 17:31:03 +08:00
|
|
|
ret = cur_trans->aborted;
|
2012-03-02 00:24:58 +08:00
|
|
|
goto cleanup_transaction;
|
2012-10-25 17:31:03 +08:00
|
|
|
}
|
2012-03-02 00:24:58 +08:00
|
|
|
|
2009-03-13 22:10:06 +08: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);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret)
|
|
|
|
goto cleanup_transaction;
|
2009-03-13 22:10:06 +08:00
|
|
|
|
2012-06-27 04:13:18 +08:00
|
|
|
btrfs_trans_release_metadata(trans, root);
|
|
|
|
trans->block_rsv = NULL;
|
|
|
|
|
2009-03-13 08:12:45 +08:00
|
|
|
cur_trans = trans->transaction;
|
2012-03-02 00:24:58 +08:00
|
|
|
|
2009-03-13 22:10:06 +08:00
|
|
|
/*
|
|
|
|
* set the flushing flag so procs in this transaction have to
|
|
|
|
* start sending their work down.
|
|
|
|
*/
|
2009-03-13 08:12:45 +08:00
|
|
|
cur_trans->delayed_refs.flushing = 1;
|
2009-03-13 22:10:06 +08:00
|
|
|
|
2012-09-12 04:57:25 +08:00
|
|
|
if (!list_empty(&trans->new_bgs))
|
|
|
|
btrfs_create_pending_block_groups(trans, root);
|
|
|
|
|
2009-03-13 22:17:05 +08:00
|
|
|
ret = btrfs_run_delayed_refs(trans, root, 0);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret)
|
|
|
|
goto cleanup_transaction;
|
2009-03-13 22:10:06 +08:00
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&cur_trans->commit_lock);
|
2009-03-13 08:12:45 +08:00
|
|
|
if (cur_trans->in_commit) {
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&cur_trans->commit_lock);
|
2011-04-12 03:45:29 +08:00
|
|
|
atomic_inc(&cur_trans->use_count);
|
2012-03-02 00:24:58 +08:00
|
|
|
ret = btrfs_end_transaction(trans, root);
|
2007-06-29 03:57:36 +08:00
|
|
|
|
2011-07-14 11:17:14 +08:00
|
|
|
wait_for_commit(root, cur_trans);
|
2007-08-11 04:22:09 +08:00
|
|
|
|
2007-03-23 03:59:16 +08:00
|
|
|
put_transaction(cur_trans);
|
2007-08-11 04:22:09 +08:00
|
|
|
|
2012-03-02 00:24:58 +08:00
|
|
|
return ret;
|
2007-03-23 03:59:16 +08:00
|
|
|
}
|
2008-01-03 22:08:48 +08:00
|
|
|
|
2007-04-02 22:50:19 +08:00
|
|
|
trans->transaction->in_commit = 1;
|
2008-07-18 00:54:14 +08:00
|
|
|
trans->transaction->blocked = 1;
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&cur_trans->commit_lock);
|
2010-10-30 03:37:34 +08:00
|
|
|
wake_up(&root->fs_info->transaction_blocked_wait);
|
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&root->fs_info->trans_lock);
|
2007-06-29 03:57:36 +08: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) {
|
2011-04-12 03:45:29 +08:00
|
|
|
atomic_inc(&prev_trans->use_count);
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
2007-06-29 03:57:36 +08:00
|
|
|
|
|
|
|
wait_for_commit(root, prev_trans);
|
|
|
|
|
2007-08-11 04:22:09 +08:00
|
|
|
put_transaction(prev_trans);
|
2011-04-12 05:25:13 +08:00
|
|
|
} else {
|
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
2007-06-29 03:57:36 +08:00
|
|
|
}
|
2011-04-12 05:25:13 +08:00
|
|
|
} else {
|
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
2007-06-29 03:57:36 +08:00
|
|
|
}
|
2007-08-11 04:22:09 +08:00
|
|
|
|
2012-07-24 03:23:45 +08:00
|
|
|
if (!btrfs_test_opt(root, SSD) &&
|
|
|
|
(now < cur_trans->start_time || now - cur_trans->start_time < 1))
|
2009-03-13 08:12:45 +08:00
|
|
|
should_grow = 1;
|
|
|
|
|
2007-08-11 04:22:09 +08:00
|
|
|
do {
|
|
|
|
joined = cur_trans->num_joined;
|
2008-08-06 01:05:02 +08:00
|
|
|
|
2007-04-02 22:50:19 +08:00
|
|
|
WARN_ON(cur_trans != trans->transaction);
|
2007-08-11 04:22:09 +08:00
|
|
|
|
2012-11-01 15:33:14 +08:00
|
|
|
ret = btrfs_flush_all_pending_stuffs(trans, root);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret)
|
|
|
|
goto cleanup_transaction;
|
btrfs: implement delayed inode items operation
Changelog V5 -> V6:
- Fix oom when the memory load is high, by storing the delayed nodes into the
root's radix tree, and letting btrfs inodes go.
Changelog V4 -> V5:
- Fix the race on adding the delayed node to the inode, which is spotted by
Chris Mason.
- Merge Chris Mason's incremental patch into this patch.
- Fix deadlock between readdir() and memory fault, which is reported by
Itaru Kitayama.
Changelog V3 -> V4:
- Fix nested lock, which is reported by Itaru Kitayama, by updating space cache
inode in time.
Changelog V2 -> V3:
- Fix the race between the delayed worker and the task which does delayed items
balance, which is reported by Tsutomu Itoh.
- Modify the patch address David Sterba's comment.
- Fix the bug of the cpu recursion spinlock, reported by Chris Mason
Changelog V1 -> V2:
- break up the global rb-tree, use a list to manage the delayed nodes,
which is created for every directory and file, and used to manage the
delayed directory name index items and the delayed inode item.
- introduce a worker to deal with the delayed nodes.
Compare with Ext3/4, the performance of file creation and deletion on btrfs
is very poor. the reason is that btrfs must do a lot of b+ tree insertions,
such as inode item, directory name item, directory name index and so on.
If we can do some delayed b+ tree insertion or deletion, we can improve the
performance, so we made this patch which implemented delayed directory name
index insertion/deletion and delayed inode update.
Implementation:
- introduce a delayed root object into the filesystem, that use two lists to
manage the delayed nodes which are created for every file/directory.
One is used to manage all the delayed nodes that have delayed items. And the
other is used to manage the delayed nodes which is waiting to be dealt with
by the work thread.
- Every delayed node has two rb-tree, one is used to manage the directory name
index which is going to be inserted into b+ tree, and the other is used to
manage the directory name index which is going to be deleted from b+ tree.
- introduce a worker to deal with the delayed operation. This worker is used
to deal with the works of the delayed directory name index items insertion
and deletion and the delayed inode update.
When the delayed items is beyond the lower limit, we create works for some
delayed nodes and insert them into the work queue of the worker, and then
go back.
When the delayed items is beyond the upper bound, we create works for all
the delayed nodes that haven't been dealt with, and insert them into the work
queue of the worker, and then wait for that the untreated items is below some
threshold value.
- When we want to insert a directory name index into b+ tree, we just add the
information into the delayed inserting rb-tree.
And then we check the number of the delayed items and do delayed items
balance. (The balance policy is above.)
- When we want to delete a directory name index from the b+ tree, we search it
in the inserting rb-tree at first. If we look it up, just drop it. If not,
add the key of it into the delayed deleting rb-tree.
Similar to the delayed inserting rb-tree, we also check the number of the
delayed items and do delayed items balance.
(The same to inserting manipulation)
- When we want to update the metadata of some inode, we cached the data of the
inode into the delayed node. the worker will flush it into the b+ tree after
dealing with the delayed insertion and deletion.
- We will move the delayed node to the tail of the list after we access the
delayed node, By this way, we can cache more delayed items and merge more
inode updates.
- If we want to commit transaction, we will deal with all the delayed node.
- the delayed node will be freed when we free the btrfs inode.
- Before we log the inode items, we commit all the directory name index items
and the delayed inode update.
I did a quick test by the benchmark tool[1] and found we can improve the
performance of file creation by ~15%, and file deletion by ~20%.
Before applying this patch:
Create files:
Total files: 50000
Total time: 1.096108
Average time: 0.000022
Delete files:
Total files: 50000
Total time: 1.510403
Average time: 0.000030
After applying this patch:
Create files:
Total files: 50000
Total time: 0.932899
Average time: 0.000019
Delete files:
Total files: 50000
Total time: 1.215732
Average time: 0.000024
[1] http://marc.info/?l=linux-btrfs&m=128212635122920&q=p3
Many thanks for Kitayama-san's help!
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Reviewed-by: David Sterba <dave@jikos.cz>
Tested-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Tested-by: Itaru Kitayama <kitayama@cl.bb4u.ne.jp>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-04-22 18:12:22 +08:00
|
|
|
|
2010-05-25 22:12:41 +08:00
|
|
|
prepare_to_wait(&cur_trans->writer_wait, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
|
2011-04-12 03:45:29 +08:00
|
|
|
if (atomic_read(&cur_trans->num_writers) > 1)
|
2010-10-30 03:37:34 +08:00
|
|
|
schedule_timeout(MAX_SCHEDULE_TIMEOUT);
|
|
|
|
else if (should_grow)
|
|
|
|
schedule_timeout(1);
|
2007-08-11 04:22:09 +08:00
|
|
|
|
|
|
|
finish_wait(&cur_trans->writer_wait, &wait);
|
2011-04-12 03:45:29 +08:00
|
|
|
} while (atomic_read(&cur_trans->num_writers) > 1 ||
|
2009-03-13 08:12:45 +08:00
|
|
|
(should_grow && cur_trans->num_joined != joined));
|
2007-08-11 04:22:09 +08:00
|
|
|
|
2012-11-01 15:33:14 +08:00
|
|
|
ret = btrfs_flush_all_pending_stuffs(trans, root);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup_transaction;
|
|
|
|
|
2011-06-15 04:22:15 +08:00
|
|
|
/*
|
|
|
|
* Ok now we need to make sure to block out any other joins while we
|
|
|
|
* commit the transaction. We could have started a join before setting
|
|
|
|
* no_join so make sure to wait for num_writers to == 1 again.
|
|
|
|
*/
|
|
|
|
spin_lock(&root->fs_info->trans_lock);
|
|
|
|
root->fs_info->trans_no_join = 1;
|
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
|
|
|
wait_event(cur_trans->writer_wait,
|
|
|
|
atomic_read(&cur_trans->num_writers) == 1);
|
|
|
|
|
2011-06-14 08:00:16 +08:00
|
|
|
/*
|
|
|
|
* the reloc mutex makes sure that we stop
|
|
|
|
* the balancing code from coming in and moving
|
|
|
|
* extents around in the middle of the commit
|
|
|
|
*/
|
|
|
|
mutex_lock(&root->fs_info->reloc_mutex);
|
|
|
|
|
2012-09-06 18:03:32 +08:00
|
|
|
/*
|
|
|
|
* We needn't worry about the delayed items because we will
|
|
|
|
* deal with them in create_pending_snapshot(), which is the
|
|
|
|
* core function of the snapshot creation.
|
|
|
|
*/
|
|
|
|
ret = create_pending_snapshots(trans, root->fs_info);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret) {
|
|
|
|
mutex_unlock(&root->fs_info->reloc_mutex);
|
|
|
|
goto cleanup_transaction;
|
|
|
|
}
|
2008-01-09 04:46:30 +08:00
|
|
|
|
2012-09-06 18:03:32 +08:00
|
|
|
/*
|
|
|
|
* We insert the dir indexes of the snapshots and update the inode
|
|
|
|
* of the snapshots' parents after the snapshot creation, so there
|
|
|
|
* are some delayed items which are not dealt with. Now deal with
|
|
|
|
* them.
|
|
|
|
*
|
|
|
|
* We needn't worry that this operation will corrupt the snapshots,
|
|
|
|
* because all the tree which are snapshoted will be forced to COW
|
|
|
|
* the nodes and leaves.
|
|
|
|
*/
|
|
|
|
ret = btrfs_run_delayed_items(trans, root);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret) {
|
|
|
|
mutex_unlock(&root->fs_info->reloc_mutex);
|
|
|
|
goto cleanup_transaction;
|
|
|
|
}
|
btrfs: implement delayed inode items operation
Changelog V5 -> V6:
- Fix oom when the memory load is high, by storing the delayed nodes into the
root's radix tree, and letting btrfs inodes go.
Changelog V4 -> V5:
- Fix the race on adding the delayed node to the inode, which is spotted by
Chris Mason.
- Merge Chris Mason's incremental patch into this patch.
- Fix deadlock between readdir() and memory fault, which is reported by
Itaru Kitayama.
Changelog V3 -> V4:
- Fix nested lock, which is reported by Itaru Kitayama, by updating space cache
inode in time.
Changelog V2 -> V3:
- Fix the race between the delayed worker and the task which does delayed items
balance, which is reported by Tsutomu Itoh.
- Modify the patch address David Sterba's comment.
- Fix the bug of the cpu recursion spinlock, reported by Chris Mason
Changelog V1 -> V2:
- break up the global rb-tree, use a list to manage the delayed nodes,
which is created for every directory and file, and used to manage the
delayed directory name index items and the delayed inode item.
- introduce a worker to deal with the delayed nodes.
Compare with Ext3/4, the performance of file creation and deletion on btrfs
is very poor. the reason is that btrfs must do a lot of b+ tree insertions,
such as inode item, directory name item, directory name index and so on.
If we can do some delayed b+ tree insertion or deletion, we can improve the
performance, so we made this patch which implemented delayed directory name
index insertion/deletion and delayed inode update.
Implementation:
- introduce a delayed root object into the filesystem, that use two lists to
manage the delayed nodes which are created for every file/directory.
One is used to manage all the delayed nodes that have delayed items. And the
other is used to manage the delayed nodes which is waiting to be dealt with
by the work thread.
- Every delayed node has two rb-tree, one is used to manage the directory name
index which is going to be inserted into b+ tree, and the other is used to
manage the directory name index which is going to be deleted from b+ tree.
- introduce a worker to deal with the delayed operation. This worker is used
to deal with the works of the delayed directory name index items insertion
and deletion and the delayed inode update.
When the delayed items is beyond the lower limit, we create works for some
delayed nodes and insert them into the work queue of the worker, and then
go back.
When the delayed items is beyond the upper bound, we create works for all
the delayed nodes that haven't been dealt with, and insert them into the work
queue of the worker, and then wait for that the untreated items is below some
threshold value.
- When we want to insert a directory name index into b+ tree, we just add the
information into the delayed inserting rb-tree.
And then we check the number of the delayed items and do delayed items
balance. (The balance policy is above.)
- When we want to delete a directory name index from the b+ tree, we search it
in the inserting rb-tree at first. If we look it up, just drop it. If not,
add the key of it into the delayed deleting rb-tree.
Similar to the delayed inserting rb-tree, we also check the number of the
delayed items and do delayed items balance.
(The same to inserting manipulation)
- When we want to update the metadata of some inode, we cached the data of the
inode into the delayed node. the worker will flush it into the b+ tree after
dealing with the delayed insertion and deletion.
- We will move the delayed node to the tail of the list after we access the
delayed node, By this way, we can cache more delayed items and merge more
inode updates.
- If we want to commit transaction, we will deal with all the delayed node.
- the delayed node will be freed when we free the btrfs inode.
- Before we log the inode items, we commit all the directory name index items
and the delayed inode update.
I did a quick test by the benchmark tool[1] and found we can improve the
performance of file creation by ~15%, and file deletion by ~20%.
Before applying this patch:
Create files:
Total files: 50000
Total time: 1.096108
Average time: 0.000022
Delete files:
Total files: 50000
Total time: 1.510403
Average time: 0.000030
After applying this patch:
Create files:
Total files: 50000
Total time: 0.932899
Average time: 0.000019
Delete files:
Total files: 50000
Total time: 1.215732
Average time: 0.000024
[1] http://marc.info/?l=linux-btrfs&m=128212635122920&q=p3
Many thanks for Kitayama-san's help!
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Reviewed-by: David Sterba <dave@jikos.cz>
Tested-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Tested-by: Itaru Kitayama <kitayama@cl.bb4u.ne.jp>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-04-22 18:12:22 +08:00
|
|
|
|
2009-03-13 22:10:06 +08:00
|
|
|
ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret) {
|
|
|
|
mutex_unlock(&root->fs_info->reloc_mutex);
|
|
|
|
goto cleanup_transaction;
|
|
|
|
}
|
2009-03-13 22:10:06 +08:00
|
|
|
|
2011-06-18 04:14:09 +08:00
|
|
|
/*
|
|
|
|
* make sure none of the code above managed to slip in a
|
|
|
|
* delayed item
|
|
|
|
*/
|
|
|
|
btrfs_assert_delayed_root_empty(root);
|
|
|
|
|
2007-04-02 22:50:19 +08:00
|
|
|
WARN_ON(cur_trans != trans->transaction);
|
2008-01-09 04:46:30 +08:00
|
|
|
|
2011-03-08 21:14:00 +08:00
|
|
|
btrfs_scrub_pause(root);
|
2008-09-06 04:13:11 +08: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 22:45:14 +08:00
|
|
|
ret = commit_fs_roots(trans, root);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret) {
|
|
|
|
mutex_unlock(&root->fs_info->tree_log_mutex);
|
2012-04-03 00:31:37 +08:00
|
|
|
mutex_unlock(&root->fs_info->reloc_mutex);
|
2012-03-02 00:24:58 +08:00
|
|
|
goto cleanup_transaction;
|
|
|
|
}
|
2007-06-23 02:16:25 +08: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 22:45:14 +08:00
|
|
|
/* commit_fs_roots gets rid of all the tree log roots, it is now
|
2008-09-06 04:13:11 +08: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 22:45:14 +08:00
|
|
|
ret = commit_cowonly_roots(trans, root);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret) {
|
|
|
|
mutex_unlock(&root->fs_info->tree_log_mutex);
|
2012-04-03 00:31:37 +08:00
|
|
|
mutex_unlock(&root->fs_info->reloc_mutex);
|
2012-03-02 00:24:58 +08:00
|
|
|
goto cleanup_transaction;
|
|
|
|
}
|
2007-06-23 02:16:25 +08:00
|
|
|
|
2009-09-12 04:11:19 +08:00
|
|
|
btrfs_prepare_extent_commit(trans, root);
|
|
|
|
|
2007-03-25 23:35:08 +08:00
|
|
|
cur_trans = root->fs_info->running_transaction;
|
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 22:45:14 +08: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 09:29:25 +08: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 22:45:14 +08: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 09:29:25 +08: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 22:45:14 +08:00
|
|
|
|
2012-06-29 00:04:55 +08:00
|
|
|
assert_qgroups_uptodate(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 22:45:14 +08:00
|
|
|
update_super_roots(root);
|
2008-09-06 04:13:11 +08:00
|
|
|
|
|
|
|
if (!root->fs_info->log_root_recovering) {
|
2011-04-13 21:41:04 +08:00
|
|
|
btrfs_set_super_log_root(root->fs_info->super_copy, 0);
|
|
|
|
btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
|
2008-09-06 04:13:11 +08:00
|
|
|
}
|
|
|
|
|
2011-04-13 21:41:04 +08:00
|
|
|
memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
|
|
|
|
sizeof(*root->fs_info->super_copy));
|
2007-06-29 03:57:36 +08:00
|
|
|
|
2008-07-18 00:54:14 +08:00
|
|
|
trans->transaction->blocked = 0;
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&root->fs_info->trans_lock);
|
|
|
|
root->fs_info->running_transaction = NULL;
|
|
|
|
root->fs_info->trans_no_join = 0;
|
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
2011-06-14 08:00:16 +08:00
|
|
|
mutex_unlock(&root->fs_info->reloc_mutex);
|
2009-03-13 08:12:45 +08:00
|
|
|
|
2008-07-18 00:54:14 +08:00
|
|
|
wake_up(&root->fs_info->transaction_wait);
|
2008-07-18 00:53:50 +08:00
|
|
|
|
2007-03-23 03:59:16 +08:00
|
|
|
ret = btrfs_write_and_wait_transaction(trans, root);
|
2012-03-02 00:24:58 +08:00
|
|
|
if (ret) {
|
|
|
|
btrfs_error(root->fs_info, ret,
|
|
|
|
"Error while writing out transaction.");
|
|
|
|
mutex_unlock(&root->fs_info->tree_log_mutex);
|
|
|
|
goto cleanup_transaction;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = write_ctree_super(trans, root, 0);
|
|
|
|
if (ret) {
|
|
|
|
mutex_unlock(&root->fs_info->tree_log_mutex);
|
|
|
|
goto cleanup_transaction;
|
|
|
|
}
|
2008-01-03 22:08:48 +08:00
|
|
|
|
2008-09-06 04:13:11 +08: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-12 04:11:19 +08:00
|
|
|
btrfs_finish_extent_commit(trans, root);
|
2008-01-03 22:08:48 +08:00
|
|
|
|
2007-04-02 22:50:19 +08:00
|
|
|
cur_trans->commit_done = 1;
|
2009-03-13 08:12:45 +08:00
|
|
|
|
2007-08-11 04:22:09 +08: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 09:29:25 +08:00
|
|
|
|
2007-04-02 22:50:19 +08:00
|
|
|
wake_up(&cur_trans->commit_wait);
|
2008-11-18 10:02:50 +08:00
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&root->fs_info->trans_lock);
|
2011-04-12 03:45:29 +08:00
|
|
|
list_del_init(&cur_trans->list);
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&root->fs_info->trans_lock);
|
|
|
|
|
2007-03-25 23:35:08 +08:00
|
|
|
put_transaction(cur_trans);
|
2007-03-23 03:59:16 +08:00
|
|
|
put_transaction(cur_trans);
|
2007-08-30 03:47:34 +08:00
|
|
|
|
Btrfs: fix orphan transaction on the freezed filesystem
With the following debug patch:
static int btrfs_freeze(struct super_block *sb)
{
+ struct btrfs_fs_info *fs_info = btrfs_sb(sb);
+ struct btrfs_transaction *trans;
+
+ spin_lock(&fs_info->trans_lock);
+ trans = fs_info->running_transaction;
+ if (trans) {
+ printk("Transid %llu, use_count %d, num_writer %d\n",
+ trans->transid, atomic_read(&trans->use_count),
+ atomic_read(&trans->num_writers));
+ }
+ spin_unlock(&fs_info->trans_lock);
return 0;
}
I found there was a orphan transaction after the freeze operation was done.
It is because the transaction may not be committed when the transaction handle
end even though it is the last handle of the current transaction. This design
avoid committing the transaction frequently, but also introduce the above
problem.
So I add btrfs_attach_transaction() which can catch the current transaction
and commit it. If there is no transaction, it will return ENOENT, and do not
anything.
This function also can be used to instead of btrfs_join_transaction_freeze()
because it don't increase the writer counter and don't start a new transaction,
so it also can fix the deadlock between sync and freeze.
Besides that, it is used to instead of btrfs_join_transaction() in
transaction_kthread(), because if there is no transaction, the transaction
kthread needn't anything.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-20 15:54:00 +08:00
|
|
|
if (trans->type < TRANS_JOIN_NOLOCK)
|
|
|
|
sb_end_intwrite(root->fs_info->sb);
|
2012-06-12 22:20:45 +08:00
|
|
|
|
Btrfs: add initial tracepoint support for btrfs
Tracepoints can provide insight into why btrfs hits bugs and be greatly
helpful for debugging, e.g
dd-7822 [000] 2121.641088: btrfs_inode_request: root = 5(FS_TREE), gen = 4, ino = 256, blocks = 8, disk_i_size = 0, last_trans = 8, logged_trans = 0
dd-7822 [000] 2121.641100: btrfs_inode_new: root = 5(FS_TREE), gen = 8, ino = 257, blocks = 0, disk_i_size = 0, last_trans = 0, logged_trans = 0
btrfs-transacti-7804 [001] 2146.935420: btrfs_cow_block: root = 2(EXTENT_TREE), refs = 2, orig_buf = 29368320 (orig_level = 0), cow_buf = 29388800 (cow_level = 0)
btrfs-transacti-7804 [001] 2146.935473: btrfs_cow_block: root = 1(ROOT_TREE), refs = 2, orig_buf = 29364224 (orig_level = 0), cow_buf = 29392896 (cow_level = 0)
btrfs-transacti-7804 [001] 2146.972221: btrfs_transaction_commit: root = 1(ROOT_TREE), gen = 8
flush-btrfs-2-7821 [001] 2155.824210: btrfs_chunk_alloc: root = 3(CHUNK_TREE), offset = 1103101952, size = 1073741824, num_stripes = 1, sub_stripes = 0, type = DATA
flush-btrfs-2-7821 [001] 2155.824241: btrfs_cow_block: root = 2(EXTENT_TREE), refs = 2, orig_buf = 29388800 (orig_level = 0), cow_buf = 29396992 (cow_level = 0)
flush-btrfs-2-7821 [001] 2155.824255: btrfs_cow_block: root = 4(DEV_TREE), refs = 2, orig_buf = 29372416 (orig_level = 0), cow_buf = 29401088 (cow_level = 0)
flush-btrfs-2-7821 [000] 2155.824329: btrfs_cow_block: root = 3(CHUNK_TREE), refs = 2, orig_buf = 20971520 (orig_level = 0), cow_buf = 20975616 (cow_level = 0)
btrfs-endio-wri-7800 [001] 2155.898019: btrfs_cow_block: root = 5(FS_TREE), refs = 2, orig_buf = 29384704 (orig_level = 0), cow_buf = 29405184 (cow_level = 0)
btrfs-endio-wri-7800 [001] 2155.898043: btrfs_cow_block: root = 7(CSUM_TREE), refs = 2, orig_buf = 29376512 (orig_level = 0), cow_buf = 29409280 (cow_level = 0)
Here is what I have added:
1) ordere_extent:
btrfs_ordered_extent_add
btrfs_ordered_extent_remove
btrfs_ordered_extent_start
btrfs_ordered_extent_put
These provide critical information to understand how ordered_extents are
updated.
2) extent_map:
btrfs_get_extent
extent_map is used in both read and write cases, and it is useful for tracking
how btrfs specific IO is running.
3) writepage:
__extent_writepage
btrfs_writepage_end_io_hook
Pages are cirtical resourses and produce a lot of corner cases during writeback,
so it is valuable to know how page is written to disk.
4) inode:
btrfs_inode_new
btrfs_inode_request
btrfs_inode_evict
These can show where and when a inode is created, when a inode is evicted.
5) sync:
btrfs_sync_file
btrfs_sync_fs
These show sync arguments.
6) transaction:
btrfs_transaction_commit
In transaction based filesystem, it will be useful to know the generation and
who does commit.
7) back reference and cow:
btrfs_delayed_tree_ref
btrfs_delayed_data_ref
btrfs_delayed_ref_head
btrfs_cow_block
Btrfs natively supports back references, these tracepoints are helpful on
understanding btrfs's COW mechanism.
8) chunk:
btrfs_chunk_alloc
btrfs_chunk_free
Chunk is a link between physical offset and logical offset, and stands for space
infomation in btrfs, and these are helpful on tracing space things.
9) reserved_extent:
btrfs_reserved_extent_alloc
btrfs_reserved_extent_free
These can show how btrfs uses its space.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-24 19:18:59 +08:00
|
|
|
trace_btrfs_transaction_commit(root);
|
|
|
|
|
2011-03-08 21:14:00 +08:00
|
|
|
btrfs_scrub_continue(root);
|
|
|
|
|
2009-09-12 04:12:44 +08:00
|
|
|
if (current->journal_info == trans)
|
|
|
|
current->journal_info = NULL;
|
|
|
|
|
2007-04-02 22:50:19 +08:00
|
|
|
kmem_cache_free(btrfs_trans_handle_cachep, trans);
|
2009-11-12 17:36:34 +08:00
|
|
|
|
|
|
|
if (current != root->fs_info->transaction_kthread)
|
|
|
|
btrfs_run_delayed_iputs(root);
|
|
|
|
|
2007-03-23 03:59:16 +08:00
|
|
|
return ret;
|
2012-03-02 00:24:58 +08:00
|
|
|
|
|
|
|
cleanup_transaction:
|
2012-06-27 04:13:18 +08:00
|
|
|
btrfs_trans_release_metadata(trans, root);
|
|
|
|
trans->block_rsv = NULL;
|
2012-03-02 00:24:58 +08:00
|
|
|
btrfs_printk(root->fs_info, "Skipping commit of aborted transaction.\n");
|
|
|
|
// WARN_ON(1);
|
|
|
|
if (current->journal_info == trans)
|
|
|
|
current->journal_info = NULL;
|
2012-06-01 03:52:43 +08:00
|
|
|
cleanup_transaction(trans, root, ret);
|
2012-03-02 00:24:58 +08:00
|
|
|
|
|
|
|
return ret;
|
2007-03-23 03:59:16 +08:00
|
|
|
}
|
|
|
|
|
2008-09-30 03:18:18 +08:00
|
|
|
/*
|
|
|
|
* interface function to delete all the snapshots we have scheduled for deletion
|
|
|
|
*/
|
2007-08-11 02:06:19 +08: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 22:45:14 +08:00
|
|
|
LIST_HEAD(list);
|
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
|
|
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_lock(&fs_info->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 22:45:14 +08:00
|
|
|
list_splice_init(&fs_info->dead_roots, &list);
|
2011-04-12 05:25:13 +08:00
|
|
|
spin_unlock(&fs_info->trans_lock);
|
2007-08-11 02:06:19 +08: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 22:45:14 +08:00
|
|
|
while (!list_empty(&list)) {
|
2011-10-04 11:22:41 +08:00
|
|
|
int 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 22:45:14 +08:00
|
|
|
root = list_entry(list.next, struct btrfs_root, root_list);
|
2009-09-22 04:00:26 +08:00
|
|
|
list_del(&root->root_list);
|
|
|
|
|
btrfs: implement delayed inode items operation
Changelog V5 -> V6:
- Fix oom when the memory load is high, by storing the delayed nodes into the
root's radix tree, and letting btrfs inodes go.
Changelog V4 -> V5:
- Fix the race on adding the delayed node to the inode, which is spotted by
Chris Mason.
- Merge Chris Mason's incremental patch into this patch.
- Fix deadlock between readdir() and memory fault, which is reported by
Itaru Kitayama.
Changelog V3 -> V4:
- Fix nested lock, which is reported by Itaru Kitayama, by updating space cache
inode in time.
Changelog V2 -> V3:
- Fix the race between the delayed worker and the task which does delayed items
balance, which is reported by Tsutomu Itoh.
- Modify the patch address David Sterba's comment.
- Fix the bug of the cpu recursion spinlock, reported by Chris Mason
Changelog V1 -> V2:
- break up the global rb-tree, use a list to manage the delayed nodes,
which is created for every directory and file, and used to manage the
delayed directory name index items and the delayed inode item.
- introduce a worker to deal with the delayed nodes.
Compare with Ext3/4, the performance of file creation and deletion on btrfs
is very poor. the reason is that btrfs must do a lot of b+ tree insertions,
such as inode item, directory name item, directory name index and so on.
If we can do some delayed b+ tree insertion or deletion, we can improve the
performance, so we made this patch which implemented delayed directory name
index insertion/deletion and delayed inode update.
Implementation:
- introduce a delayed root object into the filesystem, that use two lists to
manage the delayed nodes which are created for every file/directory.
One is used to manage all the delayed nodes that have delayed items. And the
other is used to manage the delayed nodes which is waiting to be dealt with
by the work thread.
- Every delayed node has two rb-tree, one is used to manage the directory name
index which is going to be inserted into b+ tree, and the other is used to
manage the directory name index which is going to be deleted from b+ tree.
- introduce a worker to deal with the delayed operation. This worker is used
to deal with the works of the delayed directory name index items insertion
and deletion and the delayed inode update.
When the delayed items is beyond the lower limit, we create works for some
delayed nodes and insert them into the work queue of the worker, and then
go back.
When the delayed items is beyond the upper bound, we create works for all
the delayed nodes that haven't been dealt with, and insert them into the work
queue of the worker, and then wait for that the untreated items is below some
threshold value.
- When we want to insert a directory name index into b+ tree, we just add the
information into the delayed inserting rb-tree.
And then we check the number of the delayed items and do delayed items
balance. (The balance policy is above.)
- When we want to delete a directory name index from the b+ tree, we search it
in the inserting rb-tree at first. If we look it up, just drop it. If not,
add the key of it into the delayed deleting rb-tree.
Similar to the delayed inserting rb-tree, we also check the number of the
delayed items and do delayed items balance.
(The same to inserting manipulation)
- When we want to update the metadata of some inode, we cached the data of the
inode into the delayed node. the worker will flush it into the b+ tree after
dealing with the delayed insertion and deletion.
- We will move the delayed node to the tail of the list after we access the
delayed node, By this way, we can cache more delayed items and merge more
inode updates.
- If we want to commit transaction, we will deal with all the delayed node.
- the delayed node will be freed when we free the btrfs inode.
- Before we log the inode items, we commit all the directory name index items
and the delayed inode update.
I did a quick test by the benchmark tool[1] and found we can improve the
performance of file creation by ~15%, and file deletion by ~20%.
Before applying this patch:
Create files:
Total files: 50000
Total time: 1.096108
Average time: 0.000022
Delete files:
Total files: 50000
Total time: 1.510403
Average time: 0.000030
After applying this patch:
Create files:
Total files: 50000
Total time: 0.932899
Average time: 0.000019
Delete files:
Total files: 50000
Total time: 1.215732
Average time: 0.000024
[1] http://marc.info/?l=linux-btrfs&m=128212635122920&q=p3
Many thanks for Kitayama-san's help!
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Reviewed-by: David Sterba <dave@jikos.cz>
Tested-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Tested-by: Itaru Kitayama <kitayama@cl.bb4u.ne.jp>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-04-22 18:12:22 +08:00
|
|
|
btrfs_kill_all_delayed_nodes(root);
|
|
|
|
|
2009-09-22 04:00:26 +08:00
|
|
|
if (btrfs_header_backref_rev(root->node) <
|
|
|
|
BTRFS_MIXED_BACKREF_REV)
|
2011-10-04 11:22:41 +08:00
|
|
|
ret = btrfs_drop_snapshot(root, NULL, 0, 0);
|
2009-09-22 04:00:26 +08:00
|
|
|
else
|
2011-10-04 11:22:41 +08:00
|
|
|
ret =btrfs_drop_snapshot(root, NULL, 1, 0);
|
|
|
|
BUG_ON(ret < 0);
|
2007-08-11 02:06:19 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|