2007-06-12 09:07:21 -04:00
|
|
|
/*
|
2008-09-29 15:18:18 -04:00
|
|
|
* Copyright (C) 2007,2008 Oracle. All rights reserved.
|
2007-06-12 09:07:21 -04:00
|
|
|
*
|
|
|
|
|
* 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-10-15 16:22:39 -04:00
|
|
|
#include <linux/sched.h>
|
2007-02-02 09:18:22 -05:00
|
|
|
#include "ctree.h"
|
|
|
|
|
#include "disk-io.h"
|
2007-03-23 15:56:19 -04:00
|
|
|
#include "transaction.h"
|
2007-10-15 16:14:19 -04:00
|
|
|
#include "print-tree.h"
|
2008-06-25 16:01:30 -04:00
|
|
|
#include "locking.h"
|
2007-02-23 08:38:36 -05:00
|
|
|
|
2007-03-16 16:20:31 -04:00
|
|
|
static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
|
|
|
|
|
*root, struct btrfs_path *path, int level);
|
|
|
|
|
static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
|
2007-04-04 14:08:15 -04:00
|
|
|
*root, struct btrfs_key *ins_key,
|
2007-10-25 15:42:57 -04:00
|
|
|
struct btrfs_path *path, int data_size, int extend);
|
2007-10-15 16:14:19 -04:00
|
|
|
static int push_node_left(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root, struct extent_buffer *dst,
|
2008-04-24 10:54:32 -04:00
|
|
|
struct extent_buffer *src, int empty);
|
2007-10-15 16:14:19 -04:00
|
|
|
static int balance_node_right(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct extent_buffer *dst_buf,
|
|
|
|
|
struct extent_buffer *src_buf);
|
2007-03-16 16:20:31 -04:00
|
|
|
static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path, int level, int slot);
|
2007-02-20 16:40:44 -05:00
|
|
|
|
2007-04-04 09:36:31 -04:00
|
|
|
struct btrfs_path *btrfs_alloc_path(void)
|
2007-04-02 10:50:19 -04:00
|
|
|
{
|
2007-04-04 09:36:31 -04:00
|
|
|
struct btrfs_path *path;
|
2009-02-12 14:11:25 -05:00
|
|
|
path = kmem_cache_zalloc(btrfs_path_cachep, GFP_NOFS);
|
|
|
|
|
if (path)
|
2007-08-27 16:49:44 -04:00
|
|
|
path->reada = 1;
|
2007-04-04 09:36:31 -04:00
|
|
|
return path;
|
2007-04-02 10:50:19 -04:00
|
|
|
}
|
|
|
|
|
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
/*
|
|
|
|
|
* set all locked nodes in the path to blocking locks. This should
|
|
|
|
|
* be done before scheduling
|
|
|
|
|
*/
|
|
|
|
|
noinline void btrfs_set_path_blocking(struct btrfs_path *p)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < BTRFS_MAX_LEVEL; i++) {
|
|
|
|
|
if (p->nodes[i] && p->locks[i])
|
|
|
|
|
btrfs_set_lock_blocking(p->nodes[i]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* reset all the locked nodes in the patch to spinning locks.
|
2009-02-12 14:09:45 -05:00
|
|
|
*
|
|
|
|
|
* held is used to keep lockdep happy, when lockdep is enabled
|
|
|
|
|
* we set held to a blocking lock before we go around and
|
|
|
|
|
* retake all the spinlocks in the path. You can safely use NULL
|
|
|
|
|
* for held
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
*/
|
2009-02-12 14:09:45 -05:00
|
|
|
noinline void btrfs_clear_path_blocking(struct btrfs_path *p,
|
|
|
|
|
struct extent_buffer *held)
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
{
|
|
|
|
|
int i;
|
2009-02-12 14:09:45 -05:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
|
|
|
/* lockdep really cares that we take all of these spinlocks
|
|
|
|
|
* in the right order. If any of the locks in the path are not
|
|
|
|
|
* currently blocking, it is going to complain. So, make really
|
|
|
|
|
* really sure by forcing the path to blocking before we clear
|
|
|
|
|
* the path blocking.
|
|
|
|
|
*/
|
|
|
|
|
if (held)
|
|
|
|
|
btrfs_set_lock_blocking(held);
|
|
|
|
|
btrfs_set_path_blocking(p);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
for (i = BTRFS_MAX_LEVEL - 1; i >= 0; i--) {
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
if (p->nodes[i] && p->locks[i])
|
|
|
|
|
btrfs_clear_lock_blocking(p->nodes[i]);
|
|
|
|
|
}
|
2009-02-12 14:09:45 -05:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
|
|
|
if (held)
|
|
|
|
|
btrfs_clear_lock_blocking(held);
|
|
|
|
|
#endif
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/* this also releases the path */
|
2007-04-04 09:36:31 -04:00
|
|
|
void btrfs_free_path(struct btrfs_path *p)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
2007-04-04 09:36:31 -04:00
|
|
|
btrfs_release_path(NULL, p);
|
|
|
|
|
kmem_cache_free(btrfs_path_cachep, p);
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
|
|
|
|
* path release drops references on the extent buffers in the path
|
|
|
|
|
* and it drops any locks held by this path
|
|
|
|
|
*
|
|
|
|
|
* It is safe to call this on paths that no locks or extent buffers held.
|
|
|
|
|
*/
|
2009-01-05 21:25:51 -05:00
|
|
|
noinline void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p)
|
2007-02-02 09:18:22 -05:00
|
|
|
{
|
|
|
|
|
int i;
|
2008-06-25 16:01:30 -04:00
|
|
|
|
2007-03-13 10:46:10 -04:00
|
|
|
for (i = 0; i < BTRFS_MAX_LEVEL; i++) {
|
2008-06-25 16:01:31 -04:00
|
|
|
p->slots[i] = 0;
|
2007-02-02 09:18:22 -05:00
|
|
|
if (!p->nodes[i])
|
2008-06-25 16:01:30 -04:00
|
|
|
continue;
|
|
|
|
|
if (p->locks[i]) {
|
|
|
|
|
btrfs_tree_unlock(p->nodes[i]);
|
|
|
|
|
p->locks[i] = 0;
|
|
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(p->nodes[i]);
|
2008-06-25 16:01:31 -04:00
|
|
|
p->nodes[i] = NULL;
|
2007-02-02 09:18:22 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
|
|
|
|
* safely gets a reference on the root node of a tree. A lock
|
|
|
|
|
* is not taken, so a concurrent writer may put a different node
|
|
|
|
|
* at the root of the tree. See btrfs_lock_root_node for the
|
|
|
|
|
* looping required.
|
|
|
|
|
*
|
|
|
|
|
* The extent buffer returned by this has a reference taken, so
|
|
|
|
|
* it won't disappear. It may stop being the root of the tree
|
|
|
|
|
* at any time because there are no locks held.
|
|
|
|
|
*/
|
2008-06-25 16:01:30 -04:00
|
|
|
struct extent_buffer *btrfs_root_node(struct btrfs_root *root)
|
|
|
|
|
{
|
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
|
spin_lock(&root->node_lock);
|
|
|
|
|
eb = root->node;
|
|
|
|
|
extent_buffer_get(eb);
|
|
|
|
|
spin_unlock(&root->node_lock);
|
|
|
|
|
return eb;
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/* loop around taking references on and locking the root node of the
|
|
|
|
|
* tree until you end up with a lock on the root. A locked buffer
|
|
|
|
|
* is returned, with a reference held.
|
|
|
|
|
*/
|
2008-06-25 16:01:30 -04:00
|
|
|
struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root)
|
|
|
|
|
{
|
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
|
|
2009-01-05 21:25:51 -05:00
|
|
|
while (1) {
|
2008-06-25 16:01:30 -04:00
|
|
|
eb = btrfs_root_node(root);
|
|
|
|
|
btrfs_tree_lock(eb);
|
|
|
|
|
|
|
|
|
|
spin_lock(&root->node_lock);
|
|
|
|
|
if (eb == root->node) {
|
|
|
|
|
spin_unlock(&root->node_lock);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
spin_unlock(&root->node_lock);
|
|
|
|
|
|
|
|
|
|
btrfs_tree_unlock(eb);
|
|
|
|
|
free_extent_buffer(eb);
|
|
|
|
|
}
|
|
|
|
|
return eb;
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/* cowonly root (everything not a reference counted cow subvolume), just get
|
|
|
|
|
* put onto a simple dirty list. transaction.c walks this to make sure they
|
|
|
|
|
* get properly updated on disk.
|
|
|
|
|
*/
|
2008-03-24 15:01:56 -04:00
|
|
|
static void add_root_to_dirty_list(struct btrfs_root *root)
|
|
|
|
|
{
|
|
|
|
|
if (root->track_dirty && list_empty(&root->dirty_list)) {
|
|
|
|
|
list_add(&root->dirty_list,
|
|
|
|
|
&root->fs_info->dirty_cowonly_roots);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
|
|
|
|
* used by snapshot creation to make a copy of a root for a tree with
|
|
|
|
|
* a given objectid. The buffer with the new root node is returned in
|
|
|
|
|
* cow_ret, and this func returns zero on success or a negative error code.
|
|
|
|
|
*/
|
2007-12-17 20:14:01 -05:00
|
|
|
int btrfs_copy_root(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct extent_buffer *buf,
|
|
|
|
|
struct extent_buffer **cow_ret, u64 new_root_objectid)
|
|
|
|
|
{
|
|
|
|
|
struct extent_buffer *cow;
|
|
|
|
|
u32 nritems;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int level;
|
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 10:45:14 -04:00
|
|
|
struct btrfs_disk_key disk_key;
|
2007-12-17 20:14:01 -05:00
|
|
|
|
|
|
|
|
WARN_ON(root->ref_cows && trans->transid !=
|
|
|
|
|
root->fs_info->running_transaction->transid);
|
|
|
|
|
WARN_ON(root->ref_cows && trans->transid != root->last_trans);
|
|
|
|
|
|
|
|
|
|
level = btrfs_header_level(buf);
|
|
|
|
|
nritems = btrfs_header_nritems(buf);
|
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 10:45:14 -04:00
|
|
|
if (level == 0)
|
|
|
|
|
btrfs_item_key(buf, &disk_key, 0);
|
|
|
|
|
else
|
|
|
|
|
btrfs_node_key(buf, &disk_key, 0);
|
2008-09-23 13:14:14 -04: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 10:45:14 -04:00
|
|
|
cow = btrfs_alloc_free_block(trans, root, buf->len, 0,
|
|
|
|
|
new_root_objectid, &disk_key, level,
|
|
|
|
|
buf->start, 0);
|
|
|
|
|
if (IS_ERR(cow))
|
2007-12-17 20:14:01 -05:00
|
|
|
return PTR_ERR(cow);
|
|
|
|
|
|
|
|
|
|
copy_extent_buffer(cow, buf, 0, 0, cow->len);
|
|
|
|
|
btrfs_set_header_bytenr(cow, cow->start);
|
|
|
|
|
btrfs_set_header_generation(cow, trans->transid);
|
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 10:45:14 -04:00
|
|
|
btrfs_set_header_backref_rev(cow, BTRFS_MIXED_BACKREF_REV);
|
|
|
|
|
btrfs_clear_header_flag(cow, BTRFS_HEADER_FLAG_WRITTEN |
|
|
|
|
|
BTRFS_HEADER_FLAG_RELOC);
|
|
|
|
|
if (new_root_objectid == BTRFS_TREE_RELOC_OBJECTID)
|
|
|
|
|
btrfs_set_header_flag(cow, BTRFS_HEADER_FLAG_RELOC);
|
|
|
|
|
else
|
|
|
|
|
btrfs_set_header_owner(cow, new_root_objectid);
|
2007-12-17 20:14:01 -05:00
|
|
|
|
2008-11-17 21:11:30 -05:00
|
|
|
write_extent_buffer(cow, root->fs_info->fsid,
|
|
|
|
|
(unsigned long)btrfs_header_fsid(cow),
|
|
|
|
|
BTRFS_FSID_SIZE);
|
|
|
|
|
|
2007-12-17 20:14:01 -05:00
|
|
|
WARN_ON(btrfs_header_generation(buf) > trans->transid);
|
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 10:45:14 -04:00
|
|
|
if (new_root_objectid == BTRFS_TREE_RELOC_OBJECTID)
|
|
|
|
|
ret = btrfs_inc_ref(trans, root, cow, 1);
|
|
|
|
|
else
|
|
|
|
|
ret = btrfs_inc_ref(trans, root, cow, 0);
|
2007-12-18 16:25:45 -05:00
|
|
|
|
2007-12-17 20:14:01 -05:00
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
btrfs_mark_buffer_dirty(cow);
|
|
|
|
|
*cow_ret = cow;
|
|
|
|
|
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 10:45:14 -04:00
|
|
|
/*
|
|
|
|
|
* check if the tree block can be shared by multiple trees
|
|
|
|
|
*/
|
|
|
|
|
int btrfs_block_can_be_shared(struct btrfs_root *root,
|
|
|
|
|
struct extent_buffer *buf)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* Tree blocks not in refernece counted trees and tree roots
|
|
|
|
|
* are never shared. If a block was allocated after the last
|
|
|
|
|
* snapshot and the block was not allocated by tree relocation,
|
|
|
|
|
* we know the block is not shared.
|
|
|
|
|
*/
|
|
|
|
|
if (root->ref_cows &&
|
|
|
|
|
buf != root->node && buf != root->commit_root &&
|
|
|
|
|
(btrfs_header_generation(buf) <=
|
|
|
|
|
btrfs_root_last_snapshot(&root->root_item) ||
|
|
|
|
|
btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC)))
|
|
|
|
|
return 1;
|
|
|
|
|
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
|
|
|
|
|
if (root->ref_cows &&
|
|
|
|
|
btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
|
|
|
|
|
return 1;
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct extent_buffer *buf,
|
|
|
|
|
struct extent_buffer *cow)
|
|
|
|
|
{
|
|
|
|
|
u64 refs;
|
|
|
|
|
u64 owner;
|
|
|
|
|
u64 flags;
|
|
|
|
|
u64 new_flags = 0;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Backrefs update rules:
|
|
|
|
|
*
|
|
|
|
|
* Always use full backrefs for extent pointers in tree block
|
|
|
|
|
* allocated by tree relocation.
|
|
|
|
|
*
|
|
|
|
|
* If a shared tree block is no longer referenced by its owner
|
|
|
|
|
* tree (btrfs_header_owner(buf) == root->root_key.objectid),
|
|
|
|
|
* use full backrefs for extent pointers in tree block.
|
|
|
|
|
*
|
|
|
|
|
* If a tree block is been relocating
|
|
|
|
|
* (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID),
|
|
|
|
|
* use full backrefs for extent pointers in tree block.
|
|
|
|
|
* The reason for this is some operations (such as drop tree)
|
|
|
|
|
* are only allowed for blocks use full backrefs.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if (btrfs_block_can_be_shared(root, buf)) {
|
|
|
|
|
ret = btrfs_lookup_extent_info(trans, root, buf->start,
|
|
|
|
|
buf->len, &refs, &flags);
|
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
BUG_ON(refs == 0);
|
|
|
|
|
} else {
|
|
|
|
|
refs = 1;
|
|
|
|
|
if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
|
|
|
|
|
btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
|
|
|
|
|
flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;
|
|
|
|
|
else
|
|
|
|
|
flags = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
owner = btrfs_header_owner(buf);
|
|
|
|
|
BUG_ON(owner == BTRFS_TREE_RELOC_OBJECTID &&
|
|
|
|
|
!(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF));
|
|
|
|
|
|
|
|
|
|
if (refs > 1) {
|
|
|
|
|
if ((owner == root->root_key.objectid ||
|
|
|
|
|
root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) &&
|
|
|
|
|
!(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)) {
|
|
|
|
|
ret = btrfs_inc_ref(trans, root, buf, 1);
|
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
|
|
|
|
|
if (root->root_key.objectid ==
|
|
|
|
|
BTRFS_TREE_RELOC_OBJECTID) {
|
|
|
|
|
ret = btrfs_dec_ref(trans, root, buf, 0);
|
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
ret = btrfs_inc_ref(trans, root, cow, 1);
|
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
}
|
|
|
|
|
new_flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
|
|
if (root->root_key.objectid ==
|
|
|
|
|
BTRFS_TREE_RELOC_OBJECTID)
|
|
|
|
|
ret = btrfs_inc_ref(trans, root, cow, 1);
|
|
|
|
|
else
|
|
|
|
|
ret = btrfs_inc_ref(trans, root, cow, 0);
|
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
}
|
|
|
|
|
if (new_flags != 0) {
|
|
|
|
|
ret = btrfs_set_disk_extent_flags(trans, root,
|
|
|
|
|
buf->start,
|
|
|
|
|
buf->len,
|
|
|
|
|
new_flags, 0);
|
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
|
|
|
|
|
if (root->root_key.objectid ==
|
|
|
|
|
BTRFS_TREE_RELOC_OBJECTID)
|
|
|
|
|
ret = btrfs_inc_ref(trans, root, cow, 1);
|
|
|
|
|
else
|
|
|
|
|
ret = btrfs_inc_ref(trans, root, cow, 0);
|
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
ret = btrfs_dec_ref(trans, root, buf, 1);
|
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
}
|
|
|
|
|
clean_tree_block(trans, root, buf);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
2009-01-05 21:25:51 -05:00
|
|
|
* does the dirty work in cow of a single block. The parent block (if
|
|
|
|
|
* supplied) is updated to point to the new cow copy. The new buffer is marked
|
|
|
|
|
* dirty and returned locked. If you modify the block it needs to be marked
|
|
|
|
|
* dirty again.
|
2008-09-29 15:18:18 -04:00
|
|
|
*
|
|
|
|
|
* search_start -- an allocation hint for the new block
|
|
|
|
|
*
|
2009-01-05 21:25:51 -05:00
|
|
|
* empty_size -- a hint that you plan on doing more cow. This is the size in
|
|
|
|
|
* bytes the allocator should try to find free next to the block it returns.
|
|
|
|
|
* This is just a hint and may be ignored by the allocator.
|
2008-09-29 15:18:18 -04:00
|
|
|
*/
|
2009-01-05 21:25:51 -05:00
|
|
|
static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans,
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct extent_buffer *buf,
|
|
|
|
|
struct extent_buffer *parent, int parent_slot,
|
|
|
|
|
struct extent_buffer **cow_ret,
|
2009-03-13 10:24:59 -04:00
|
|
|
u64 search_start, u64 empty_size)
|
2007-03-02 16:08:05 -05: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 10:45:14 -04:00
|
|
|
struct btrfs_disk_key disk_key;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *cow;
|
2007-12-11 09:25:06 -05:00
|
|
|
int level;
|
2008-06-25 16:01:30 -04:00
|
|
|
int unlock_orig = 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 10:45:14 -04:00
|
|
|
u64 parent_start;
|
2007-12-11 09:25:06 -05:00
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
if (*cow_ret == buf)
|
|
|
|
|
unlock_orig = 1;
|
|
|
|
|
|
2009-03-09 11:45:38 -04:00
|
|
|
btrfs_assert_tree_locked(buf);
|
2008-06-25 16:01:30 -04:00
|
|
|
|
2007-12-11 09:25:06 -05:00
|
|
|
WARN_ON(root->ref_cows && trans->transid !=
|
|
|
|
|
root->fs_info->running_transaction->transid);
|
2007-08-07 16:15:09 -04:00
|
|
|
WARN_ON(root->ref_cows && trans->transid != root->last_trans);
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2007-12-11 09:25:06 -05:00
|
|
|
level = btrfs_header_level(buf);
|
2008-09-23 13:14:14 -04: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 10:45:14 -04:00
|
|
|
if (level == 0)
|
|
|
|
|
btrfs_item_key(buf, &disk_key, 0);
|
|
|
|
|
else
|
|
|
|
|
btrfs_node_key(buf, &disk_key, 0);
|
|
|
|
|
|
|
|
|
|
if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
|
|
|
|
|
if (parent)
|
|
|
|
|
parent_start = parent->start;
|
|
|
|
|
else
|
|
|
|
|
parent_start = 0;
|
|
|
|
|
} else
|
|
|
|
|
parent_start = 0;
|
|
|
|
|
|
|
|
|
|
cow = btrfs_alloc_free_block(trans, root, buf->len, parent_start,
|
|
|
|
|
root->root_key.objectid, &disk_key,
|
|
|
|
|
level, search_start, empty_size);
|
2007-06-22 14:16:25 -04:00
|
|
|
if (IS_ERR(cow))
|
|
|
|
|
return PTR_ERR(cow);
|
2007-08-07 16:15:09 -04:00
|
|
|
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
/* cow is set to blocking by btrfs_init_new_buffer */
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
copy_extent_buffer(cow, buf, 0, 0, cow->len);
|
2007-10-15 16:15:53 -04:00
|
|
|
btrfs_set_header_bytenr(cow, cow->start);
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_generation(cow, trans->transid);
|
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 10:45:14 -04:00
|
|
|
btrfs_set_header_backref_rev(cow, BTRFS_MIXED_BACKREF_REV);
|
|
|
|
|
btrfs_clear_header_flag(cow, BTRFS_HEADER_FLAG_WRITTEN |
|
|
|
|
|
BTRFS_HEADER_FLAG_RELOC);
|
|
|
|
|
if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
|
|
|
|
|
btrfs_set_header_flag(cow, BTRFS_HEADER_FLAG_RELOC);
|
|
|
|
|
else
|
|
|
|
|
btrfs_set_header_owner(cow, root->root_key.objectid);
|
2007-08-07 16:15:09 -04:00
|
|
|
|
2008-11-17 21:11:30 -05:00
|
|
|
write_extent_buffer(cow, root->fs_info->fsid,
|
|
|
|
|
(unsigned long)btrfs_header_fsid(cow),
|
|
|
|
|
BTRFS_FSID_SIZE);
|
|
|
|
|
|
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 10:45:14 -04:00
|
|
|
update_ref_for_cow(trans, root, buf, cow);
|
Btrfs: update space balancing code
This patch updates the space balancing code to utilize the new
backref format. Before, btrfs-vol -b would break any COW links
on data blocks or metadata. This was slow and caused the amount
of space used to explode if a large number of snapshots were present.
The new code can keeps the sharing of all data extents and
most of the tree blocks.
To maintain the sharing of data extents, the space balance code uses
a seperate inode hold data extent pointers, then updates the references
to point to the new location.
To maintain the sharing of tree blocks, the space balance code uses
reloc trees to relocate tree blocks in reference counted roots.
There is one reloc tree for each subvol, and all reloc trees share
same root key objectid. Reloc trees are snapshots of the latest
committed roots of subvols (root->commit_root).
To relocate a tree block referenced by a subvol, there are two steps.
COW the block through subvol's reloc tree, then update block pointer in
the subvol to point to the new block. Since all reloc trees share
same root key objectid, doing special handing for tree blocks
owned by them is easy. Once a tree block has been COWed in one
reloc tree, we can use the resulting new block directly when the
same block is required to COW again through other reloc trees.
In this way, relocated tree blocks are shared between reloc trees,
so they are also shared between subvols.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-09-26 10:09:34 -04:00
|
|
|
|
2007-03-02 16:08:05 -05:00
|
|
|
if (buf == root->node) {
|
2008-06-25 16:01:30 -04:00
|
|
|
WARN_ON(parent && parent != buf);
|
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 10:45:14 -04:00
|
|
|
if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
|
|
|
|
|
btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
|
|
|
|
|
parent_start = buf->start;
|
|
|
|
|
else
|
|
|
|
|
parent_start = 0;
|
2008-06-25 16:01:30 -04:00
|
|
|
|
|
|
|
|
spin_lock(&root->node_lock);
|
2007-03-02 16:08:05 -05:00
|
|
|
root->node = cow;
|
2007-10-15 16:14:19 -04:00
|
|
|
extent_buffer_get(cow);
|
2008-06-25 16:01:30 -04:00
|
|
|
spin_unlock(&root->node_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 10:45:14 -04:00
|
|
|
btrfs_free_extent(trans, root, buf->start, buf->len,
|
|
|
|
|
parent_start, root->root_key.objectid,
|
|
|
|
|
level, 0);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(buf);
|
2008-03-24 15:01:56 -04:00
|
|
|
add_root_to_dirty_list(root);
|
2007-03-02 16:08:05 -05:00
|
|
|
} else {
|
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 10:45:14 -04:00
|
|
|
if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
|
|
|
|
|
parent_start = parent->start;
|
|
|
|
|
else
|
|
|
|
|
parent_start = 0;
|
|
|
|
|
|
|
|
|
|
WARN_ON(trans->transid != btrfs_header_generation(parent));
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_node_blockptr(parent, parent_slot,
|
2007-10-15 16:15:53 -04:00
|
|
|
cow->start);
|
2007-12-11 09:25:06 -05:00
|
|
|
btrfs_set_node_ptr_generation(parent, parent_slot,
|
|
|
|
|
trans->transid);
|
2007-03-30 14:27:56 -04:00
|
|
|
btrfs_mark_buffer_dirty(parent);
|
2007-12-11 09:25:06 -05:00
|
|
|
btrfs_free_extent(trans, root, buf->start, buf->len,
|
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 10:45:14 -04:00
|
|
|
parent_start, root->root_key.objectid,
|
|
|
|
|
level, 0);
|
2007-03-02 16:08:05 -05:00
|
|
|
}
|
2008-06-25 16:01:30 -04:00
|
|
|
if (unlock_orig)
|
|
|
|
|
btrfs_tree_unlock(buf);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(buf);
|
2007-06-28 15:57:36 -04:00
|
|
|
btrfs_mark_buffer_dirty(cow);
|
2007-04-02 10:50:19 -04:00
|
|
|
*cow_ret = cow;
|
2007-03-02 16:08:05 -05: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 10:45:14 -04:00
|
|
|
static inline int should_cow_block(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct extent_buffer *buf)
|
|
|
|
|
{
|
|
|
|
|
if (btrfs_header_generation(buf) == trans->transid &&
|
|
|
|
|
!btrfs_header_flag(buf, BTRFS_HEADER_FLAG_WRITTEN) &&
|
|
|
|
|
!(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID &&
|
|
|
|
|
btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC)))
|
|
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
|
|
|
|
* cows a single block, see __btrfs_cow_block for the real work.
|
|
|
|
|
* This version of it has extra checks so that a block isn't cow'd more than
|
|
|
|
|
* once per transaction, as long as it hasn't been written yet
|
|
|
|
|
*/
|
2009-01-05 21:25:51 -05:00
|
|
|
noinline int btrfs_cow_block(struct btrfs_trans_handle *trans,
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_root *root, struct extent_buffer *buf,
|
|
|
|
|
struct extent_buffer *parent, int parent_slot,
|
2009-03-13 10:24:59 -04:00
|
|
|
struct extent_buffer **cow_ret)
|
2007-08-07 16:15:09 -04:00
|
|
|
{
|
|
|
|
|
u64 search_start;
|
2007-10-15 16:14:48 -04:00
|
|
|
int ret;
|
2008-01-08 15:46:30 -05:00
|
|
|
|
2007-08-07 16:15:09 -04:00
|
|
|
if (trans->transaction != root->fs_info->running_transaction) {
|
2009-01-05 21:25:51 -05:00
|
|
|
printk(KERN_CRIT "trans %llu running %llu\n",
|
|
|
|
|
(unsigned long long)trans->transid,
|
|
|
|
|
(unsigned long long)
|
2007-08-07 16:15:09 -04:00
|
|
|
root->fs_info->running_transaction->transid);
|
|
|
|
|
WARN_ON(1);
|
|
|
|
|
}
|
|
|
|
|
if (trans->transid != root->fs_info->generation) {
|
2009-01-05 21:25:51 -05:00
|
|
|
printk(KERN_CRIT "trans %llu running %llu\n",
|
|
|
|
|
(unsigned long long)trans->transid,
|
|
|
|
|
(unsigned long long)root->fs_info->generation);
|
2007-08-07 16:15:09 -04:00
|
|
|
WARN_ON(1);
|
|
|
|
|
}
|
2008-01-08 15:46:30 -05: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 10:45:14 -04:00
|
|
|
if (!should_cow_block(trans, root, buf)) {
|
2007-08-07 16:15:09 -04:00
|
|
|
*cow_ret = buf;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2009-02-04 09:24:25 -05:00
|
|
|
|
2008-03-24 15:01:56 -04:00
|
|
|
search_start = buf->start & ~((u64)(1024 * 1024 * 1024) - 1);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
|
|
|
|
|
if (parent)
|
|
|
|
|
btrfs_set_lock_blocking(parent);
|
|
|
|
|
btrfs_set_lock_blocking(buf);
|
|
|
|
|
|
2007-10-15 16:14:48 -04:00
|
|
|
ret = __btrfs_cow_block(trans, root, buf, parent,
|
2009-03-13 10:24:59 -04:00
|
|
|
parent_slot, cow_ret, search_start, 0);
|
2007-10-15 16:14:48 -04:00
|
|
|
return ret;
|
2007-08-07 16:15:09 -04:00
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
|
|
|
|
* helper function for defrag to decide if two blocks pointed to by a
|
|
|
|
|
* node are actually close by
|
|
|
|
|
*/
|
2007-10-15 16:17:34 -04:00
|
|
|
static int close_blocks(u64 blocknr, u64 other, u32 blocksize)
|
2007-08-07 16:15:09 -04:00
|
|
|
{
|
2007-10-15 16:17:34 -04:00
|
|
|
if (blocknr < other && other - (blocknr + blocksize) < 32768)
|
2007-08-07 16:15:09 -04:00
|
|
|
return 1;
|
2007-10-15 16:17:34 -04:00
|
|
|
if (blocknr > other && blocknr - (other + blocksize) < 32768)
|
2007-08-07 16:15:09 -04:00
|
|
|
return 1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-06 10:26:24 -05:00
|
|
|
/*
|
|
|
|
|
* compare two keys in a memcmp fashion
|
|
|
|
|
*/
|
|
|
|
|
static int comp_keys(struct btrfs_disk_key *disk, struct btrfs_key *k2)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_key k1;
|
|
|
|
|
|
|
|
|
|
btrfs_disk_key_to_cpu(&k1, disk);
|
|
|
|
|
|
2009-07-24 11:06:52 -04:00
|
|
|
return btrfs_comp_cpu_keys(&k1, k2);
|
2007-11-06 10:26:24 -05:00
|
|
|
}
|
|
|
|
|
|
2008-11-12 14:19:50 -05:00
|
|
|
/*
|
|
|
|
|
* same as comp_keys only with two btrfs_key's
|
|
|
|
|
*/
|
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 10:45:14 -04:00
|
|
|
int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2)
|
2008-11-12 14:19:50 -05:00
|
|
|
{
|
|
|
|
|
if (k1->objectid > k2->objectid)
|
|
|
|
|
return 1;
|
|
|
|
|
if (k1->objectid < k2->objectid)
|
|
|
|
|
return -1;
|
|
|
|
|
if (k1->type > k2->type)
|
|
|
|
|
return 1;
|
|
|
|
|
if (k1->type < k2->type)
|
|
|
|
|
return -1;
|
|
|
|
|
if (k1->offset > k2->offset)
|
|
|
|
|
return 1;
|
|
|
|
|
if (k1->offset < k2->offset)
|
|
|
|
|
return -1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2007-11-06 10:26:24 -05:00
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
|
|
|
|
* this is used by the defrag code to go through all the
|
|
|
|
|
* leaves pointed to by a node and reallocate them so that
|
|
|
|
|
* disk order is close to key order
|
|
|
|
|
*/
|
2007-08-07 16:15:09 -04:00
|
|
|
int btrfs_realloc_node(struct btrfs_trans_handle *trans,
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_root *root, struct extent_buffer *parent,
|
2007-10-15 16:22:39 -04:00
|
|
|
int start_slot, int cache_only, u64 *last_ret,
|
|
|
|
|
struct btrfs_key *progress)
|
2007-08-07 16:15:09 -04:00
|
|
|
{
|
2007-10-15 16:17:34 -04:00
|
|
|
struct extent_buffer *cur;
|
2007-08-07 16:15:09 -04:00
|
|
|
u64 blocknr;
|
2008-05-12 12:59:19 -04:00
|
|
|
u64 gen;
|
2007-08-10 14:06:19 -04:00
|
|
|
u64 search_start = *last_ret;
|
|
|
|
|
u64 last_block = 0;
|
2007-08-07 16:15:09 -04:00
|
|
|
u64 other;
|
|
|
|
|
u32 parent_nritems;
|
|
|
|
|
int end_slot;
|
|
|
|
|
int i;
|
|
|
|
|
int err = 0;
|
2007-08-10 14:42:37 -04:00
|
|
|
int parent_level;
|
2007-10-15 16:17:34 -04:00
|
|
|
int uptodate;
|
|
|
|
|
u32 blocksize;
|
2007-11-06 10:26:24 -05:00
|
|
|
int progress_passed = 0;
|
|
|
|
|
struct btrfs_disk_key disk_key;
|
2007-08-07 16:15:09 -04:00
|
|
|
|
2007-10-25 15:43:18 -04:00
|
|
|
parent_level = btrfs_header_level(parent);
|
|
|
|
|
if (cache_only && parent_level != 1)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2009-01-05 21:25:51 -05:00
|
|
|
if (trans->transaction != root->fs_info->running_transaction)
|
2007-08-07 16:15:09 -04:00
|
|
|
WARN_ON(1);
|
2009-01-05 21:25:51 -05:00
|
|
|
if (trans->transid != root->fs_info->generation)
|
2007-08-07 16:15:09 -04:00
|
|
|
WARN_ON(1);
|
2007-09-10 19:58:16 -04:00
|
|
|
|
2007-10-15 16:17:34 -04:00
|
|
|
parent_nritems = btrfs_header_nritems(parent);
|
|
|
|
|
blocksize = btrfs_level_size(root, parent_level - 1);
|
2007-08-07 16:15:09 -04:00
|
|
|
end_slot = parent_nritems;
|
|
|
|
|
|
|
|
|
|
if (parent_nritems == 1)
|
|
|
|
|
return 0;
|
|
|
|
|
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_lock_blocking(parent);
|
|
|
|
|
|
2007-08-07 16:15:09 -04:00
|
|
|
for (i = start_slot; i < end_slot; i++) {
|
|
|
|
|
int close = 1;
|
2007-10-15 16:22:39 -04:00
|
|
|
|
2007-10-25 15:43:18 -04:00
|
|
|
if (!parent->map_token) {
|
|
|
|
|
map_extent_buffer(parent,
|
|
|
|
|
btrfs_node_key_ptr_offset(i),
|
|
|
|
|
sizeof(struct btrfs_key_ptr),
|
|
|
|
|
&parent->map_token, &parent->kaddr,
|
|
|
|
|
&parent->map_start, &parent->map_len,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
}
|
2007-11-06 10:26:24 -05:00
|
|
|
btrfs_node_key(parent, &disk_key, i);
|
|
|
|
|
if (!progress_passed && comp_keys(&disk_key, progress) < 0)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
progress_passed = 1;
|
2007-10-15 16:17:34 -04:00
|
|
|
blocknr = btrfs_node_blockptr(parent, i);
|
2008-05-12 12:59:19 -04:00
|
|
|
gen = btrfs_node_ptr_generation(parent, i);
|
2007-08-10 14:06:19 -04:00
|
|
|
if (last_block == 0)
|
|
|
|
|
last_block = blocknr;
|
2007-10-25 15:43:18 -04:00
|
|
|
|
2007-08-07 16:15:09 -04:00
|
|
|
if (i > 0) {
|
2007-10-15 16:17:34 -04:00
|
|
|
other = btrfs_node_blockptr(parent, i - 1);
|
|
|
|
|
close = close_blocks(blocknr, other, blocksize);
|
2007-08-07 16:15:09 -04:00
|
|
|
}
|
2008-05-24 14:04:53 -04:00
|
|
|
if (!close && i < end_slot - 2) {
|
2007-10-15 16:17:34 -04:00
|
|
|
other = btrfs_node_blockptr(parent, i + 1);
|
|
|
|
|
close = close_blocks(blocknr, other, blocksize);
|
2007-08-07 16:15:09 -04:00
|
|
|
}
|
2007-08-10 14:06:19 -04:00
|
|
|
if (close) {
|
|
|
|
|
last_block = blocknr;
|
2007-08-07 16:15:09 -04:00
|
|
|
continue;
|
2007-08-10 14:06:19 -04:00
|
|
|
}
|
2007-10-25 15:43:18 -04:00
|
|
|
if (parent->map_token) {
|
|
|
|
|
unmap_extent_buffer(parent, parent->map_token,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
parent->map_token = NULL;
|
|
|
|
|
}
|
2007-08-07 16:15:09 -04:00
|
|
|
|
2007-10-15 16:17:34 -04:00
|
|
|
cur = btrfs_find_tree_block(root, blocknr, blocksize);
|
|
|
|
|
if (cur)
|
2008-05-12 13:39:03 -04:00
|
|
|
uptodate = btrfs_buffer_uptodate(cur, gen);
|
2007-10-15 16:17:34 -04:00
|
|
|
else
|
|
|
|
|
uptodate = 0;
|
2007-10-25 15:43:18 -04:00
|
|
|
if (!cur || !uptodate) {
|
2007-08-07 16:15:09 -04:00
|
|
|
if (cache_only) {
|
2007-10-15 16:17:34 -04:00
|
|
|
free_extent_buffer(cur);
|
2007-08-07 16:15:09 -04:00
|
|
|
continue;
|
|
|
|
|
}
|
2007-10-15 16:17:34 -04:00
|
|
|
if (!cur) {
|
|
|
|
|
cur = read_tree_block(root, blocknr,
|
2008-05-12 12:59:19 -04:00
|
|
|
blocksize, gen);
|
2007-10-15 16:17:34 -04:00
|
|
|
} else if (!uptodate) {
|
2008-05-12 12:59:19 -04:00
|
|
|
btrfs_read_buffer(cur, gen);
|
2007-08-10 14:42:37 -04:00
|
|
|
}
|
2007-08-07 16:15:09 -04:00
|
|
|
}
|
2007-08-10 14:06:19 -04:00
|
|
|
if (search_start == 0)
|
2007-10-15 16:17:34 -04:00
|
|
|
search_start = last_block;
|
2007-08-10 14:06:19 -04:00
|
|
|
|
2008-06-25 16:01:31 -04:00
|
|
|
btrfs_tree_lock(cur);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_lock_blocking(cur);
|
2007-10-15 16:17:34 -04:00
|
|
|
err = __btrfs_cow_block(trans, root, cur, parent, i,
|
2008-06-25 16:01:31 -04:00
|
|
|
&cur, search_start,
|
2007-10-15 16:17:34 -04:00
|
|
|
min(16 * blocksize,
|
2009-03-13 10:24:59 -04:00
|
|
|
(end_slot - i) * blocksize));
|
2007-08-29 09:11:44 -04:00
|
|
|
if (err) {
|
2008-06-25 16:01:31 -04:00
|
|
|
btrfs_tree_unlock(cur);
|
2007-10-15 16:17:34 -04:00
|
|
|
free_extent_buffer(cur);
|
2007-08-07 16:15:09 -04:00
|
|
|
break;
|
2007-08-29 09:11:44 -04:00
|
|
|
}
|
2008-06-25 16:01:31 -04:00
|
|
|
search_start = cur->start;
|
|
|
|
|
last_block = cur->start;
|
2007-08-10 14:42:37 -04:00
|
|
|
*last_ret = search_start;
|
2008-06-25 16:01:31 -04:00
|
|
|
btrfs_tree_unlock(cur);
|
|
|
|
|
free_extent_buffer(cur);
|
2007-08-07 16:15:09 -04:00
|
|
|
}
|
2007-10-25 15:43:18 -04:00
|
|
|
if (parent->map_token) {
|
|
|
|
|
unmap_extent_buffer(parent, parent->map_token,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
parent->map_token = NULL;
|
|
|
|
|
}
|
2007-08-07 16:15:09 -04:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/*
|
|
|
|
|
* The leaf data grows from end-to-front in the node.
|
|
|
|
|
* this returns the address of the start of the last item,
|
|
|
|
|
* which is the stop of the leaf data stack
|
|
|
|
|
*/
|
2007-03-14 14:14:43 -04:00
|
|
|
static inline unsigned int leaf_data_end(struct btrfs_root *root,
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *leaf)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
u32 nr = btrfs_header_nritems(leaf);
|
2007-01-26 15:51:26 -05:00
|
|
|
if (nr == 0)
|
2007-03-14 14:14:43 -04:00
|
|
|
return BTRFS_LEAF_DATA_SIZE(root);
|
2007-10-15 16:14:19 -04:00
|
|
|
return btrfs_item_offset_nr(leaf, nr - 1);
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
|
|
|
|
* extra debugging checks to make sure all the items in a key are
|
|
|
|
|
* well formed and in the proper order
|
|
|
|
|
*/
|
2007-03-14 14:14:43 -04:00
|
|
|
static int check_node(struct btrfs_root *root, struct btrfs_path *path,
|
|
|
|
|
int level)
|
2007-02-28 16:35:06 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *parent = NULL;
|
|
|
|
|
struct extent_buffer *node = path->nodes[level];
|
|
|
|
|
struct btrfs_disk_key parent_key;
|
|
|
|
|
struct btrfs_disk_key node_key;
|
2007-02-28 16:35:06 -05:00
|
|
|
int parent_slot;
|
2007-05-10 11:24:42 -04:00
|
|
|
int slot;
|
|
|
|
|
struct btrfs_key cpukey;
|
2007-10-15 16:14:19 -04:00
|
|
|
u32 nritems = btrfs_header_nritems(node);
|
2007-02-28 16:35:06 -05:00
|
|
|
|
|
|
|
|
if (path->nodes[level + 1])
|
2007-10-15 16:14:19 -04:00
|
|
|
parent = path->nodes[level + 1];
|
2007-07-11 10:03:27 -04:00
|
|
|
|
2007-05-10 11:24:42 -04:00
|
|
|
slot = path->slots[level];
|
2007-03-12 12:01:18 -04:00
|
|
|
BUG_ON(nritems == 0);
|
|
|
|
|
if (parent) {
|
2007-07-11 10:03:27 -04:00
|
|
|
parent_slot = path->slots[level + 1];
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_node_key(parent, &parent_key, parent_slot);
|
|
|
|
|
btrfs_node_key(node, &node_key, 0);
|
|
|
|
|
BUG_ON(memcmp(&parent_key, &node_key,
|
2007-03-12 16:22:34 -04:00
|
|
|
sizeof(struct btrfs_disk_key)));
|
2007-03-13 09:28:32 -04:00
|
|
|
BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
|
2007-10-15 16:15:53 -04:00
|
|
|
btrfs_header_bytenr(node));
|
2007-02-28 16:35:06 -05:00
|
|
|
}
|
2007-03-14 14:14:43 -04:00
|
|
|
BUG_ON(nritems > BTRFS_NODEPTRS_PER_BLOCK(root));
|
2007-05-10 11:24:42 -04:00
|
|
|
if (slot != 0) {
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_node_key_to_cpu(node, &cpukey, slot - 1);
|
|
|
|
|
btrfs_node_key(node, &node_key, slot);
|
|
|
|
|
BUG_ON(comp_keys(&node_key, &cpukey) <= 0);
|
2007-05-10 11:24:42 -04:00
|
|
|
}
|
|
|
|
|
if (slot < nritems - 1) {
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_node_key_to_cpu(node, &cpukey, slot + 1);
|
|
|
|
|
btrfs_node_key(node, &node_key, slot);
|
|
|
|
|
BUG_ON(comp_keys(&node_key, &cpukey) >= 0);
|
2007-02-28 16:35:06 -05:00
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
|
|
|
|
* extra checking to make sure all the items in a leaf are
|
|
|
|
|
* well formed and in the proper order
|
|
|
|
|
*/
|
2007-03-14 14:14:43 -04:00
|
|
|
static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
|
|
|
|
|
int level)
|
2007-02-28 16:35:06 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *leaf = path->nodes[level];
|
|
|
|
|
struct extent_buffer *parent = NULL;
|
2007-02-28 16:35:06 -05:00
|
|
|
int parent_slot;
|
2007-05-10 11:24:42 -04:00
|
|
|
struct btrfs_key cpukey;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_disk_key parent_key;
|
|
|
|
|
struct btrfs_disk_key leaf_key;
|
|
|
|
|
int slot = path->slots[0];
|
2007-05-10 11:24:42 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
u32 nritems = btrfs_header_nritems(leaf);
|
2007-02-28 16:35:06 -05:00
|
|
|
|
|
|
|
|
if (path->nodes[level + 1])
|
2007-10-15 16:14:19 -04:00
|
|
|
parent = path->nodes[level + 1];
|
2007-03-12 12:01:18 -04:00
|
|
|
|
|
|
|
|
if (nritems == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (parent) {
|
2007-07-11 10:03:27 -04:00
|
|
|
parent_slot = path->slots[level + 1];
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_node_key(parent, &parent_key, parent_slot);
|
|
|
|
|
btrfs_item_key(leaf, &leaf_key, 0);
|
2007-08-07 16:15:09 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
BUG_ON(memcmp(&parent_key, &leaf_key,
|
2007-03-12 16:22:34 -04:00
|
|
|
sizeof(struct btrfs_disk_key)));
|
2007-03-13 09:28:32 -04:00
|
|
|
BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
|
2007-10-15 16:15:53 -04:00
|
|
|
btrfs_header_bytenr(leaf));
|
2007-10-15 16:14:19 -04:00
|
|
|
}
|
|
|
|
|
if (slot != 0 && slot < nritems - 1) {
|
|
|
|
|
btrfs_item_key(leaf, &leaf_key, slot);
|
|
|
|
|
btrfs_item_key_to_cpu(leaf, &cpukey, slot - 1);
|
|
|
|
|
if (comp_keys(&leaf_key, &cpukey) <= 0) {
|
|
|
|
|
btrfs_print_leaf(root, leaf);
|
2009-01-05 21:25:51 -05:00
|
|
|
printk(KERN_CRIT "slot %d offset bad key\n", slot);
|
2007-10-15 16:14:19 -04:00
|
|
|
BUG_ON(1);
|
|
|
|
|
}
|
|
|
|
|
if (btrfs_item_offset_nr(leaf, slot - 1) !=
|
|
|
|
|
btrfs_item_end_nr(leaf, slot)) {
|
|
|
|
|
btrfs_print_leaf(root, leaf);
|
2009-01-05 21:25:51 -05:00
|
|
|
printk(KERN_CRIT "slot %d offset bad\n", slot);
|
2007-10-15 16:14:19 -04:00
|
|
|
BUG_ON(1);
|
|
|
|
|
}
|
2007-05-10 11:24:42 -04:00
|
|
|
}
|
|
|
|
|
if (slot < nritems - 1) {
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_item_key(leaf, &leaf_key, slot);
|
|
|
|
|
btrfs_item_key_to_cpu(leaf, &cpukey, slot + 1);
|
|
|
|
|
BUG_ON(comp_keys(&leaf_key, &cpukey) >= 0);
|
|
|
|
|
if (btrfs_item_offset_nr(leaf, slot) !=
|
|
|
|
|
btrfs_item_end_nr(leaf, slot + 1)) {
|
|
|
|
|
btrfs_print_leaf(root, leaf);
|
2009-01-05 21:25:51 -05:00
|
|
|
printk(KERN_CRIT "slot %d offset bad\n", slot);
|
2007-10-15 16:14:19 -04:00
|
|
|
BUG_ON(1);
|
|
|
|
|
}
|
2007-02-28 16:35:06 -05:00
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
BUG_ON(btrfs_item_offset_nr(leaf, 0) +
|
|
|
|
|
btrfs_item_size_nr(leaf, 0) != BTRFS_LEAF_DATA_SIZE(root));
|
2007-02-28 16:35:06 -05:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-01-05 21:25:51 -05:00
|
|
|
static noinline int check_block(struct btrfs_root *root,
|
2008-01-03 10:01:48 -05:00
|
|
|
struct btrfs_path *path, int level)
|
2007-02-28 16:35:06 -05:00
|
|
|
{
|
2008-04-10 10:23:19 -04:00
|
|
|
return 0;
|
2007-02-28 16:35:06 -05:00
|
|
|
if (level == 0)
|
2007-03-14 14:14:43 -04:00
|
|
|
return check_leaf(root, path, level);
|
|
|
|
|
return check_node(root, path, level);
|
2007-02-28 16:35:06 -05:00
|
|
|
}
|
|
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/*
|
2007-10-15 16:14:19 -04:00
|
|
|
* search for key in the extent_buffer. The items start at offset p,
|
|
|
|
|
* and they are item_size apart. There are 'max' items in p.
|
|
|
|
|
*
|
2007-02-02 11:05:29 -05:00
|
|
|
* the slot in the array is returned via slot, and it points to
|
|
|
|
|
* the place where you would insert key if it is not found in
|
|
|
|
|
* the array.
|
|
|
|
|
*
|
|
|
|
|
* slot may point to max if the key is bigger than all of the keys
|
|
|
|
|
*/
|
2008-09-05 16:13:11 -04:00
|
|
|
static noinline int generic_bin_search(struct extent_buffer *eb,
|
|
|
|
|
unsigned long p,
|
|
|
|
|
int item_size, struct btrfs_key *key,
|
|
|
|
|
int max, int *slot)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
|
|
|
|
int low = 0;
|
|
|
|
|
int high = max;
|
|
|
|
|
int mid;
|
|
|
|
|
int ret;
|
2007-10-15 16:14:27 -04:00
|
|
|
struct btrfs_disk_key *tmp = NULL;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_disk_key unaligned;
|
|
|
|
|
unsigned long offset;
|
|
|
|
|
char *map_token = NULL;
|
|
|
|
|
char *kaddr = NULL;
|
|
|
|
|
unsigned long map_start = 0;
|
|
|
|
|
unsigned long map_len = 0;
|
2007-10-15 16:14:27 -04:00
|
|
|
int err;
|
2007-01-26 15:51:26 -05:00
|
|
|
|
2009-01-05 21:25:51 -05:00
|
|
|
while (low < high) {
|
2007-01-26 15:51:26 -05:00
|
|
|
mid = (low + high) / 2;
|
2007-10-15 16:14:19 -04:00
|
|
|
offset = p + mid * item_size;
|
|
|
|
|
|
|
|
|
|
if (!map_token || offset < map_start ||
|
|
|
|
|
(offset + sizeof(struct btrfs_disk_key)) >
|
|
|
|
|
map_start + map_len) {
|
2007-10-15 16:14:27 -04:00
|
|
|
if (map_token) {
|
2007-10-15 16:14:19 -04:00
|
|
|
unmap_extent_buffer(eb, map_token, KM_USER0);
|
2007-10-15 16:14:27 -04:00
|
|
|
map_token = NULL;
|
|
|
|
|
}
|
2008-12-08 16:43:10 -05:00
|
|
|
|
|
|
|
|
err = map_private_extent_buffer(eb, offset,
|
2007-10-15 16:14:27 -04:00
|
|
|
sizeof(struct btrfs_disk_key),
|
|
|
|
|
&map_token, &kaddr,
|
|
|
|
|
&map_start, &map_len, KM_USER0);
|
|
|
|
|
|
|
|
|
|
if (!err) {
|
|
|
|
|
tmp = (struct btrfs_disk_key *)(kaddr + offset -
|
|
|
|
|
map_start);
|
|
|
|
|
} else {
|
|
|
|
|
read_extent_buffer(eb, &unaligned,
|
|
|
|
|
offset, sizeof(unaligned));
|
|
|
|
|
tmp = &unaligned;
|
|
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
tmp = (struct btrfs_disk_key *)(kaddr + offset -
|
|
|
|
|
map_start);
|
|
|
|
|
}
|
2007-01-26 15:51:26 -05:00
|
|
|
ret = comp_keys(tmp, key);
|
|
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
low = mid + 1;
|
|
|
|
|
else if (ret > 0)
|
|
|
|
|
high = mid;
|
|
|
|
|
else {
|
|
|
|
|
*slot = mid;
|
2007-10-15 16:14:27 -04:00
|
|
|
if (map_token)
|
|
|
|
|
unmap_extent_buffer(eb, map_token, KM_USER0);
|
2007-01-26 15:51:26 -05:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
*slot = low;
|
2007-10-15 16:14:19 -04:00
|
|
|
if (map_token)
|
|
|
|
|
unmap_extent_buffer(eb, map_token, KM_USER0);
|
2007-01-26 15:51:26 -05:00
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-24 13:39:08 -05:00
|
|
|
/*
|
|
|
|
|
* simple bin_search frontend that does the right thing for
|
|
|
|
|
* leaves vs nodes
|
|
|
|
|
*/
|
2007-10-15 16:14:19 -04:00
|
|
|
static int bin_search(struct extent_buffer *eb, struct btrfs_key *key,
|
|
|
|
|
int level, int *slot)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
if (level == 0) {
|
|
|
|
|
return generic_bin_search(eb,
|
|
|
|
|
offsetof(struct btrfs_leaf, items),
|
2007-03-12 20:12:07 -04:00
|
|
|
sizeof(struct btrfs_item),
|
2007-10-15 16:14:19 -04:00
|
|
|
key, btrfs_header_nritems(eb),
|
2007-03-12 12:01:18 -04:00
|
|
|
slot);
|
2007-01-26 15:51:26 -05:00
|
|
|
} else {
|
2007-10-15 16:14:19 -04:00
|
|
|
return generic_bin_search(eb,
|
|
|
|
|
offsetof(struct btrfs_node, ptrs),
|
2007-03-14 14:14:43 -04:00
|
|
|
sizeof(struct btrfs_key_ptr),
|
2007-10-15 16:14:19 -04:00
|
|
|
key, btrfs_header_nritems(eb),
|
2007-03-12 12:01:18 -04:00
|
|
|
slot);
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
return -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 10:45:14 -04:00
|
|
|
int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,
|
|
|
|
|
int level, int *slot)
|
|
|
|
|
{
|
|
|
|
|
return bin_search(eb, key, level, slot);
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/* given a node and slot number, this reads the blocks it points to. The
|
|
|
|
|
* extent buffer is returned with a reference taken (but unlocked).
|
|
|
|
|
* NULL is returned on error.
|
|
|
|
|
*/
|
2008-09-05 16:13:11 -04:00
|
|
|
static noinline struct extent_buffer *read_node_slot(struct btrfs_root *root,
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *parent, int slot)
|
2007-03-01 12:04:21 -05:00
|
|
|
{
|
2008-05-12 12:59:19 -04:00
|
|
|
int level = btrfs_header_level(parent);
|
2007-03-01 12:04:21 -05:00
|
|
|
if (slot < 0)
|
|
|
|
|
return NULL;
|
2007-10-15 16:14:19 -04:00
|
|
|
if (slot >= btrfs_header_nritems(parent))
|
2007-03-01 12:04:21 -05:00
|
|
|
return NULL;
|
2008-05-12 12:59:19 -04:00
|
|
|
|
|
|
|
|
BUG_ON(level == 0);
|
|
|
|
|
|
2007-10-15 16:15:53 -04:00
|
|
|
return read_tree_block(root, btrfs_node_blockptr(parent, slot),
|
2008-05-12 12:59:19 -04:00
|
|
|
btrfs_level_size(root, level - 1),
|
|
|
|
|
btrfs_node_ptr_generation(parent, slot));
|
2007-03-01 12:04:21 -05:00
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
|
|
|
|
* node level balancing, used to make sure nodes are in proper order for
|
|
|
|
|
* item deletion. We balance from the top down, so we have to make sure
|
|
|
|
|
* that a deletion won't leave an node completely empty later on.
|
|
|
|
|
*/
|
2008-09-05 16:13:11 -04:00
|
|
|
static noinline int balance_level(struct btrfs_trans_handle *trans,
|
2008-01-03 10:01:48 -05:00
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path, int level)
|
2007-03-01 12:04:21 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *right = NULL;
|
|
|
|
|
struct extent_buffer *mid;
|
|
|
|
|
struct extent_buffer *left = NULL;
|
|
|
|
|
struct extent_buffer *parent = NULL;
|
2007-03-01 12:04:21 -05:00
|
|
|
int ret = 0;
|
|
|
|
|
int wret;
|
|
|
|
|
int pslot;
|
|
|
|
|
int orig_slot = path->slots[level];
|
2007-06-22 14:16:25 -04:00
|
|
|
int err_on_enospc = 0;
|
2007-03-01 15:16:26 -05:00
|
|
|
u64 orig_ptr;
|
2007-03-01 12:04:21 -05:00
|
|
|
|
|
|
|
|
if (level == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
mid = path->nodes[level];
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
WARN_ON(!path->locks[level]);
|
2007-12-11 09:25:06 -05:00
|
|
|
WARN_ON(btrfs_header_generation(mid) != trans->transid);
|
|
|
|
|
|
2007-03-13 09:28:32 -04:00
|
|
|
orig_ptr = btrfs_node_blockptr(mid, orig_slot);
|
2007-03-01 15:16:26 -05:00
|
|
|
|
2007-03-13 10:46:10 -04:00
|
|
|
if (level < BTRFS_MAX_LEVEL - 1)
|
2007-10-15 16:14:19 -04:00
|
|
|
parent = path->nodes[level + 1];
|
2007-03-01 12:04:21 -05:00
|
|
|
pslot = path->slots[level + 1];
|
|
|
|
|
|
2007-03-17 14:29:23 -04:00
|
|
|
/*
|
|
|
|
|
* deal with the case where there is only one pointer in the root
|
|
|
|
|
* by promoting the node below to a root
|
|
|
|
|
*/
|
2007-10-15 16:14:19 -04:00
|
|
|
if (!parent) {
|
|
|
|
|
struct extent_buffer *child;
|
2007-03-01 12:04:21 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
if (btrfs_header_nritems(mid) != 1)
|
2007-03-01 12:04:21 -05:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* promote the child to a root */
|
2007-10-15 16:14:19 -04:00
|
|
|
child = read_node_slot(root, mid, 0);
|
2009-02-12 10:06:15 -05:00
|
|
|
BUG_ON(!child);
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_lock(child);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_lock_blocking(child);
|
2009-03-13 10:24:59 -04:00
|
|
|
ret = btrfs_cow_block(trans, root, child, mid, 0, &child);
|
2008-02-01 14:58:07 -05:00
|
|
|
BUG_ON(ret);
|
|
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
spin_lock(&root->node_lock);
|
2007-03-01 12:04:21 -05:00
|
|
|
root->node = child;
|
2008-06-25 16:01:30 -04:00
|
|
|
spin_unlock(&root->node_lock);
|
|
|
|
|
|
2008-03-24 15:01:56 -04:00
|
|
|
add_root_to_dirty_list(root);
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(child);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
path->locks[level] = 0;
|
2007-03-01 12:04:21 -05:00
|
|
|
path->nodes[level] = NULL;
|
2007-10-15 16:14:19 -04:00
|
|
|
clean_tree_block(trans, root, mid);
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(mid);
|
2007-03-01 12:04:21 -05:00
|
|
|
/* once for the path */
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(mid);
|
2007-12-11 09:25:06 -05:00
|
|
|
ret = btrfs_free_extent(trans, root, mid->start, mid->len,
|
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 10:45:14 -04:00
|
|
|
0, root->root_key.objectid, level, 1);
|
2007-03-01 12:04:21 -05:00
|
|
|
/* once for the root ptr */
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(mid);
|
2007-10-15 16:15:53 -04:00
|
|
|
return ret;
|
2007-03-01 12:04:21 -05:00
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
if (btrfs_header_nritems(mid) >
|
2007-03-14 14:14:43 -04:00
|
|
|
BTRFS_NODEPTRS_PER_BLOCK(root) / 4)
|
2007-03-01 12:04:21 -05:00
|
|
|
return 0;
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
if (btrfs_header_nritems(mid) < 2)
|
2007-06-22 14:16:25 -04:00
|
|
|
err_on_enospc = 1;
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
left = read_node_slot(root, parent, pslot - 1);
|
|
|
|
|
if (left) {
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_lock(left);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_lock_blocking(left);
|
2007-10-15 16:14:19 -04:00
|
|
|
wret = btrfs_cow_block(trans, root, left,
|
2009-03-13 10:24:59 -04:00
|
|
|
parent, pslot - 1, &left);
|
2007-06-22 14:16:25 -04:00
|
|
|
if (wret) {
|
|
|
|
|
ret = wret;
|
|
|
|
|
goto enospc;
|
|
|
|
|
}
|
2007-08-27 16:49:44 -04:00
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
right = read_node_slot(root, parent, pslot + 1);
|
|
|
|
|
if (right) {
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_lock(right);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_lock_blocking(right);
|
2007-10-15 16:14:19 -04:00
|
|
|
wret = btrfs_cow_block(trans, root, right,
|
2009-03-13 10:24:59 -04:00
|
|
|
parent, pslot + 1, &right);
|
2007-08-27 16:49:44 -04:00
|
|
|
if (wret) {
|
|
|
|
|
ret = wret;
|
|
|
|
|
goto enospc;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* first, try to make some room in the middle buffer */
|
2007-10-15 16:14:19 -04:00
|
|
|
if (left) {
|
|
|
|
|
orig_slot += btrfs_header_nritems(left);
|
2008-04-24 14:42:46 -04:00
|
|
|
wret = push_node_left(trans, root, left, mid, 1);
|
2007-03-01 15:16:26 -05:00
|
|
|
if (wret < 0)
|
|
|
|
|
ret = wret;
|
2007-10-15 16:14:19 -04:00
|
|
|
if (btrfs_header_nritems(mid) < 2)
|
2007-06-22 14:16:25 -04:00
|
|
|
err_on_enospc = 1;
|
2007-03-01 12:04:21 -05:00
|
|
|
}
|
2007-03-01 15:16:26 -05:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* then try to empty the right most buffer into the middle
|
|
|
|
|
*/
|
2007-10-15 16:14:19 -04:00
|
|
|
if (right) {
|
2008-04-24 10:54:32 -04:00
|
|
|
wret = push_node_left(trans, root, mid, right, 1);
|
2007-06-22 14:16:25 -04:00
|
|
|
if (wret < 0 && wret != -ENOSPC)
|
2007-03-01 15:16:26 -05:00
|
|
|
ret = wret;
|
2007-10-15 16:14:19 -04:00
|
|
|
if (btrfs_header_nritems(right) == 0) {
|
2007-10-15 16:15:53 -04:00
|
|
|
u64 bytenr = right->start;
|
|
|
|
|
u32 blocksize = right->len;
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
clean_tree_block(trans, root, right);
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(right);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(right);
|
2007-03-01 12:04:21 -05:00
|
|
|
right = NULL;
|
2007-03-16 16:20:31 -04:00
|
|
|
wret = del_ptr(trans, root, path, level + 1, pslot +
|
|
|
|
|
1);
|
2007-03-01 12:04:21 -05:00
|
|
|
if (wret)
|
|
|
|
|
ret = wret;
|
2007-10-15 16:15:53 -04:00
|
|
|
wret = btrfs_free_extent(trans, root, bytenr,
|
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 10:45:14 -04:00
|
|
|
blocksize, 0,
|
|
|
|
|
root->root_key.objectid,
|
|
|
|
|
level, 0);
|
2007-03-01 12:04:21 -05:00
|
|
|
if (wret)
|
|
|
|
|
ret = wret;
|
|
|
|
|
} else {
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_disk_key right_key;
|
|
|
|
|
btrfs_node_key(right, &right_key, 0);
|
|
|
|
|
btrfs_set_node_key(parent, &right_key, pslot + 1);
|
|
|
|
|
btrfs_mark_buffer_dirty(parent);
|
2007-03-01 12:04:21 -05:00
|
|
|
}
|
|
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
if (btrfs_header_nritems(mid) == 1) {
|
2007-03-01 15:16:26 -05:00
|
|
|
/*
|
|
|
|
|
* we're not allowed to leave a node with one item in the
|
|
|
|
|
* tree during a delete. A deletion from lower in the tree
|
|
|
|
|
* could try to delete the only pointer in this node.
|
|
|
|
|
* So, pull some keys from the left.
|
|
|
|
|
* There has to be a left pointer at this point because
|
|
|
|
|
* otherwise we would have pulled some pointers from the
|
|
|
|
|
* right
|
|
|
|
|
*/
|
2007-10-15 16:14:19 -04:00
|
|
|
BUG_ON(!left);
|
|
|
|
|
wret = balance_node_right(trans, root, mid, left);
|
2007-06-22 14:16:25 -04:00
|
|
|
if (wret < 0) {
|
2007-03-01 15:16:26 -05:00
|
|
|
ret = wret;
|
2007-06-22 14:16:25 -04:00
|
|
|
goto enospc;
|
|
|
|
|
}
|
2008-04-24 14:42:46 -04:00
|
|
|
if (wret == 1) {
|
|
|
|
|
wret = push_node_left(trans, root, left, mid, 1);
|
|
|
|
|
if (wret < 0)
|
|
|
|
|
ret = wret;
|
|
|
|
|
}
|
2007-03-01 15:16:26 -05:00
|
|
|
BUG_ON(wret == 1);
|
|
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
if (btrfs_header_nritems(mid) == 0) {
|
2007-03-01 15:16:26 -05:00
|
|
|
/* we've managed to empty the middle node, drop it */
|
2007-10-15 16:15:53 -04:00
|
|
|
u64 bytenr = mid->start;
|
|
|
|
|
u32 blocksize = mid->len;
|
2008-06-25 16:01:30 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
clean_tree_block(trans, root, mid);
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(mid);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(mid);
|
2007-03-01 12:04:21 -05:00
|
|
|
mid = NULL;
|
2007-03-16 16:20:31 -04:00
|
|
|
wret = del_ptr(trans, root, path, level + 1, pslot);
|
2007-03-01 12:04:21 -05:00
|
|
|
if (wret)
|
|
|
|
|
ret = wret;
|
2007-12-11 09:25:06 -05:00
|
|
|
wret = btrfs_free_extent(trans, root, bytenr, blocksize,
|
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 10:45:14 -04:00
|
|
|
0, root->root_key.objectid,
|
|
|
|
|
level, 0);
|
2007-03-01 12:04:21 -05:00
|
|
|
if (wret)
|
|
|
|
|
ret = wret;
|
2007-03-01 15:16:26 -05:00
|
|
|
} else {
|
|
|
|
|
/* update the parent key to reflect our changes */
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_disk_key mid_key;
|
|
|
|
|
btrfs_node_key(mid, &mid_key, 0);
|
|
|
|
|
btrfs_set_node_key(parent, &mid_key, pslot);
|
|
|
|
|
btrfs_mark_buffer_dirty(parent);
|
2007-03-01 15:16:26 -05:00
|
|
|
}
|
2007-03-01 12:04:21 -05:00
|
|
|
|
2007-03-01 15:16:26 -05:00
|
|
|
/* update the path */
|
2007-10-15 16:14:19 -04:00
|
|
|
if (left) {
|
|
|
|
|
if (btrfs_header_nritems(left) > orig_slot) {
|
|
|
|
|
extent_buffer_get(left);
|
2008-06-25 16:01:30 -04:00
|
|
|
/* left was locked after cow */
|
2007-10-15 16:14:19 -04:00
|
|
|
path->nodes[level] = left;
|
2007-03-01 12:04:21 -05:00
|
|
|
path->slots[level + 1] -= 1;
|
|
|
|
|
path->slots[level] = orig_slot;
|
2008-06-25 16:01:30 -04:00
|
|
|
if (mid) {
|
|
|
|
|
btrfs_tree_unlock(mid);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(mid);
|
2008-06-25 16:01:30 -04:00
|
|
|
}
|
2007-03-01 12:04:21 -05:00
|
|
|
} else {
|
2007-10-15 16:14:19 -04:00
|
|
|
orig_slot -= btrfs_header_nritems(left);
|
2007-03-01 12:04:21 -05:00
|
|
|
path->slots[level] = orig_slot;
|
|
|
|
|
}
|
|
|
|
|
}
|
2007-03-01 15:16:26 -05:00
|
|
|
/* double check we haven't messed things up */
|
2007-03-14 14:14:43 -04:00
|
|
|
check_block(root, path, level);
|
2007-03-22 12:13:20 -04:00
|
|
|
if (orig_ptr !=
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_node_blockptr(path->nodes[level], path->slots[level]))
|
2007-03-01 15:16:26 -05:00
|
|
|
BUG();
|
2007-06-22 14:16:25 -04:00
|
|
|
enospc:
|
2008-06-25 16:01:30 -04:00
|
|
|
if (right) {
|
|
|
|
|
btrfs_tree_unlock(right);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(right);
|
2008-06-25 16:01:30 -04:00
|
|
|
}
|
|
|
|
|
if (left) {
|
|
|
|
|
if (path->nodes[level] != left)
|
|
|
|
|
btrfs_tree_unlock(left);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(left);
|
2008-06-25 16:01:30 -04:00
|
|
|
}
|
2007-03-01 12:04:21 -05:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/* Node balancing for insertion. Here we only split or push nodes around
|
|
|
|
|
* when they are completely full. This is also done top down, so we
|
|
|
|
|
* have to be pessimistic.
|
|
|
|
|
*/
|
2009-01-05 21:25:51 -05:00
|
|
|
static noinline int push_nodes_for_insert(struct btrfs_trans_handle *trans,
|
2008-01-03 10:01:48 -05:00
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path, int level)
|
2007-04-20 13:16:02 -04:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *right = NULL;
|
|
|
|
|
struct extent_buffer *mid;
|
|
|
|
|
struct extent_buffer *left = NULL;
|
|
|
|
|
struct extent_buffer *parent = NULL;
|
2007-04-20 13:16:02 -04:00
|
|
|
int ret = 0;
|
|
|
|
|
int wret;
|
|
|
|
|
int pslot;
|
|
|
|
|
int orig_slot = path->slots[level];
|
|
|
|
|
u64 orig_ptr;
|
|
|
|
|
|
|
|
|
|
if (level == 0)
|
|
|
|
|
return 1;
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
mid = path->nodes[level];
|
2007-12-11 09:25:06 -05:00
|
|
|
WARN_ON(btrfs_header_generation(mid) != trans->transid);
|
2007-04-20 13:16:02 -04:00
|
|
|
orig_ptr = btrfs_node_blockptr(mid, orig_slot);
|
|
|
|
|
|
|
|
|
|
if (level < BTRFS_MAX_LEVEL - 1)
|
2007-10-15 16:14:19 -04:00
|
|
|
parent = path->nodes[level + 1];
|
2007-04-20 13:16:02 -04:00
|
|
|
pslot = path->slots[level + 1];
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
if (!parent)
|
2007-04-20 13:16:02 -04:00
|
|
|
return 1;
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
left = read_node_slot(root, parent, pslot - 1);
|
2007-04-20 13:16:02 -04:00
|
|
|
|
|
|
|
|
/* first, try to make some room in the middle buffer */
|
2007-10-15 16:14:19 -04:00
|
|
|
if (left) {
|
2007-04-20 13:16:02 -04:00
|
|
|
u32 left_nr;
|
2008-06-25 16:01:30 -04:00
|
|
|
|
|
|
|
|
btrfs_tree_lock(left);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_lock_blocking(left);
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
left_nr = btrfs_header_nritems(left);
|
2007-04-20 13:48:57 -04:00
|
|
|
if (left_nr >= BTRFS_NODEPTRS_PER_BLOCK(root) - 1) {
|
|
|
|
|
wret = 1;
|
|
|
|
|
} else {
|
2007-10-15 16:14:19 -04:00
|
|
|
ret = btrfs_cow_block(trans, root, left, parent,
|
2009-03-13 10:24:59 -04:00
|
|
|
pslot - 1, &left);
|
2007-06-22 14:16:25 -04:00
|
|
|
if (ret)
|
|
|
|
|
wret = 1;
|
|
|
|
|
else {
|
|
|
|
|
wret = push_node_left(trans, root,
|
2008-04-24 10:54:32 -04:00
|
|
|
left, mid, 0);
|
2007-06-22 14:16:25 -04:00
|
|
|
}
|
2007-04-20 13:48:57 -04:00
|
|
|
}
|
2007-04-20 13:16:02 -04:00
|
|
|
if (wret < 0)
|
|
|
|
|
ret = wret;
|
|
|
|
|
if (wret == 0) {
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_disk_key disk_key;
|
2007-04-20 13:16:02 -04:00
|
|
|
orig_slot += left_nr;
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_node_key(mid, &disk_key, 0);
|
|
|
|
|
btrfs_set_node_key(parent, &disk_key, pslot);
|
|
|
|
|
btrfs_mark_buffer_dirty(parent);
|
|
|
|
|
if (btrfs_header_nritems(left) > orig_slot) {
|
|
|
|
|
path->nodes[level] = left;
|
2007-04-20 13:16:02 -04:00
|
|
|
path->slots[level + 1] -= 1;
|
|
|
|
|
path->slots[level] = orig_slot;
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(mid);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(mid);
|
2007-04-20 13:16:02 -04:00
|
|
|
} else {
|
|
|
|
|
orig_slot -=
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_header_nritems(left);
|
2007-04-20 13:16:02 -04:00
|
|
|
path->slots[level] = orig_slot;
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(left);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(left);
|
2007-04-20 13:16:02 -04:00
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(left);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(left);
|
2007-04-20 13:16:02 -04:00
|
|
|
}
|
2008-06-25 16:01:30 -04:00
|
|
|
right = read_node_slot(root, parent, pslot + 1);
|
2007-04-20 13:16:02 -04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* then try to empty the right most buffer into the middle
|
|
|
|
|
*/
|
2007-10-15 16:14:19 -04:00
|
|
|
if (right) {
|
2007-04-20 13:48:57 -04:00
|
|
|
u32 right_nr;
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_lock(right);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_lock_blocking(right);
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
right_nr = btrfs_header_nritems(right);
|
2007-04-20 13:48:57 -04:00
|
|
|
if (right_nr >= BTRFS_NODEPTRS_PER_BLOCK(root) - 1) {
|
|
|
|
|
wret = 1;
|
|
|
|
|
} else {
|
2007-10-15 16:14:19 -04:00
|
|
|
ret = btrfs_cow_block(trans, root, right,
|
|
|
|
|
parent, pslot + 1,
|
2009-03-13 10:24:59 -04:00
|
|
|
&right);
|
2007-06-22 14:16:25 -04:00
|
|
|
if (ret)
|
|
|
|
|
wret = 1;
|
|
|
|
|
else {
|
|
|
|
|
wret = balance_node_right(trans, root,
|
2007-10-15 16:14:19 -04:00
|
|
|
right, mid);
|
2007-06-22 14:16:25 -04:00
|
|
|
}
|
2007-04-20 13:48:57 -04:00
|
|
|
}
|
2007-04-20 13:16:02 -04:00
|
|
|
if (wret < 0)
|
|
|
|
|
ret = wret;
|
|
|
|
|
if (wret == 0) {
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_disk_key disk_key;
|
|
|
|
|
|
|
|
|
|
btrfs_node_key(right, &disk_key, 0);
|
|
|
|
|
btrfs_set_node_key(parent, &disk_key, pslot + 1);
|
|
|
|
|
btrfs_mark_buffer_dirty(parent);
|
|
|
|
|
|
|
|
|
|
if (btrfs_header_nritems(mid) <= orig_slot) {
|
|
|
|
|
path->nodes[level] = right;
|
2007-04-20 13:16:02 -04:00
|
|
|
path->slots[level + 1] += 1;
|
|
|
|
|
path->slots[level] = orig_slot -
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_header_nritems(mid);
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(mid);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(mid);
|
2007-04-20 13:16:02 -04:00
|
|
|
} else {
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(right);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(right);
|
2007-04-20 13:16:02 -04:00
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(right);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(right);
|
2007-04-20 13:16:02 -04:00
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-07 15:52:22 -04:00
|
|
|
/*
|
2008-09-29 15:18:18 -04:00
|
|
|
* readahead one full node of leaves, finding things that are close
|
|
|
|
|
* to the block in 'slot', and triggering ra on them.
|
2007-08-07 15:52:22 -04:00
|
|
|
*/
|
2009-04-03 10:14:18 -04:00
|
|
|
static void reada_for_search(struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path,
|
|
|
|
|
int level, int slot, u64 objectid)
|
2007-08-07 15:52:22 -04:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *node;
|
2007-12-21 16:24:26 -05:00
|
|
|
struct btrfs_disk_key disk_key;
|
2007-08-07 15:52:22 -04:00
|
|
|
u32 nritems;
|
|
|
|
|
u64 search;
|
2009-01-22 09:23:10 -05:00
|
|
|
u64 target;
|
2007-10-15 16:17:34 -04:00
|
|
|
u64 nread = 0;
|
2007-08-07 15:52:22 -04:00
|
|
|
int direction = path->reada;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *eb;
|
2007-10-15 16:17:34 -04:00
|
|
|
u32 nr;
|
|
|
|
|
u32 blocksize;
|
|
|
|
|
u32 nscan = 0;
|
2007-10-15 16:15:53 -04:00
|
|
|
|
2007-10-15 16:22:39 -04:00
|
|
|
if (level != 1)
|
2007-08-07 16:15:09 -04:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (!path->nodes[level])
|
2007-08-07 15:52:22 -04:00
|
|
|
return;
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
node = path->nodes[level];
|
2008-06-25 16:01:30 -04:00
|
|
|
|
2007-08-07 15:52:22 -04:00
|
|
|
search = btrfs_node_blockptr(node, slot);
|
2007-10-15 16:17:34 -04:00
|
|
|
blocksize = btrfs_level_size(root, level - 1);
|
|
|
|
|
eb = btrfs_find_tree_block(root, search, blocksize);
|
2007-10-15 16:14:19 -04:00
|
|
|
if (eb) {
|
|
|
|
|
free_extent_buffer(eb);
|
2007-08-07 15:52:22 -04:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2009-01-22 09:23:10 -05:00
|
|
|
target = search;
|
2007-10-15 16:17:34 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
nritems = btrfs_header_nritems(node);
|
2007-10-15 16:17:34 -04:00
|
|
|
nr = slot;
|
2009-01-05 21:25:51 -05:00
|
|
|
while (1) {
|
2007-10-15 16:17:34 -04:00
|
|
|
if (direction < 0) {
|
|
|
|
|
if (nr == 0)
|
|
|
|
|
break;
|
|
|
|
|
nr--;
|
|
|
|
|
} else if (direction > 0) {
|
|
|
|
|
nr++;
|
|
|
|
|
if (nr >= nritems)
|
|
|
|
|
break;
|
2007-08-07 15:52:22 -04:00
|
|
|
}
|
2007-12-21 16:24:26 -05:00
|
|
|
if (path->reada < 0 && objectid) {
|
|
|
|
|
btrfs_node_key(node, &disk_key, nr);
|
|
|
|
|
if (btrfs_disk_key_objectid(&disk_key) != objectid)
|
|
|
|
|
break;
|
|
|
|
|
}
|
2007-10-15 16:17:34 -04:00
|
|
|
search = btrfs_node_blockptr(node, nr);
|
2009-01-22 09:23:10 -05:00
|
|
|
if ((search <= target && target - search <= 65536) ||
|
|
|
|
|
(search > target && search - target <= 65536)) {
|
2008-05-12 12:59:19 -04:00
|
|
|
readahead_tree_block(root, search, blocksize,
|
|
|
|
|
btrfs_node_ptr_generation(node, nr));
|
2007-10-15 16:17:34 -04:00
|
|
|
nread += blocksize;
|
|
|
|
|
}
|
|
|
|
|
nscan++;
|
2009-01-22 09:23:10 -05:00
|
|
|
if ((nread > 65536 || nscan > 32))
|
2007-10-15 16:17:34 -04:00
|
|
|
break;
|
2007-08-07 15:52:22 -04:00
|
|
|
}
|
|
|
|
|
}
|
2008-06-25 16:01:30 -04:00
|
|
|
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
/*
|
|
|
|
|
* returns -EAGAIN if it had to drop the path, or zero if everything was in
|
|
|
|
|
* cache
|
|
|
|
|
*/
|
|
|
|
|
static noinline int reada_for_balance(struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path, int level)
|
|
|
|
|
{
|
|
|
|
|
int slot;
|
|
|
|
|
int nritems;
|
|
|
|
|
struct extent_buffer *parent;
|
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
|
u64 gen;
|
|
|
|
|
u64 block1 = 0;
|
|
|
|
|
u64 block2 = 0;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int blocksize;
|
|
|
|
|
|
2009-04-20 15:50:10 -04:00
|
|
|
parent = path->nodes[level + 1];
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
if (!parent)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
nritems = btrfs_header_nritems(parent);
|
2009-04-20 15:50:10 -04:00
|
|
|
slot = path->slots[level + 1];
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
blocksize = btrfs_level_size(root, level);
|
|
|
|
|
|
|
|
|
|
if (slot > 0) {
|
|
|
|
|
block1 = btrfs_node_blockptr(parent, slot - 1);
|
|
|
|
|
gen = btrfs_node_ptr_generation(parent, slot - 1);
|
|
|
|
|
eb = btrfs_find_tree_block(root, block1, blocksize);
|
|
|
|
|
if (eb && btrfs_buffer_uptodate(eb, gen))
|
|
|
|
|
block1 = 0;
|
|
|
|
|
free_extent_buffer(eb);
|
|
|
|
|
}
|
2009-04-20 15:50:10 -04:00
|
|
|
if (slot + 1 < nritems) {
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
block2 = btrfs_node_blockptr(parent, slot + 1);
|
|
|
|
|
gen = btrfs_node_ptr_generation(parent, slot + 1);
|
|
|
|
|
eb = btrfs_find_tree_block(root, block2, blocksize);
|
|
|
|
|
if (eb && btrfs_buffer_uptodate(eb, gen))
|
|
|
|
|
block2 = 0;
|
|
|
|
|
free_extent_buffer(eb);
|
|
|
|
|
}
|
|
|
|
|
if (block1 || block2) {
|
|
|
|
|
ret = -EAGAIN;
|
2009-04-20 15:50:10 -04:00
|
|
|
|
|
|
|
|
/* release the whole path */
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_release_path(root, path);
|
2009-04-20 15:50:10 -04:00
|
|
|
|
|
|
|
|
/* read the blocks */
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
if (block1)
|
|
|
|
|
readahead_tree_block(root, block1, blocksize, 0);
|
|
|
|
|
if (block2)
|
|
|
|
|
readahead_tree_block(root, block2, blocksize, 0);
|
|
|
|
|
|
|
|
|
|
if (block1) {
|
|
|
|
|
eb = read_tree_block(root, block1, blocksize, 0);
|
|
|
|
|
free_extent_buffer(eb);
|
|
|
|
|
}
|
2009-04-20 15:50:10 -04:00
|
|
|
if (block2) {
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
eb = read_tree_block(root, block2, blocksize, 0);
|
|
|
|
|
free_extent_buffer(eb);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
2009-01-05 21:25:51 -05:00
|
|
|
* when we walk down the tree, it is usually safe to unlock the higher layers
|
|
|
|
|
* in the tree. The exceptions are when our path goes through slot 0, because
|
|
|
|
|
* operations on the tree might require changing key pointers higher up in the
|
|
|
|
|
* tree.
|
2008-09-29 15:18:18 -04:00
|
|
|
*
|
2009-01-05 21:25:51 -05:00
|
|
|
* callers might also have set path->keep_locks, which tells this code to keep
|
|
|
|
|
* the lock if the path points to the last slot in the block. This is part of
|
|
|
|
|
* walking through the tree, and selecting the next slot in the higher block.
|
2008-09-29 15:18:18 -04:00
|
|
|
*
|
2009-01-05 21:25:51 -05:00
|
|
|
* lowest_unlock sets the lowest level in the tree we're allowed to unlock. so
|
|
|
|
|
* if lowest_unlock is 1, level 0 won't be unlocked
|
2008-09-29 15:18:18 -04:00
|
|
|
*/
|
2008-09-05 16:13:11 -04:00
|
|
|
static noinline void unlock_up(struct btrfs_path *path, int level,
|
|
|
|
|
int lowest_unlock)
|
2008-06-25 16:01:30 -04:00
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
int skip_level = level;
|
2008-06-25 16:01:30 -04:00
|
|
|
int no_skips = 0;
|
2008-06-25 16:01:30 -04:00
|
|
|
struct extent_buffer *t;
|
|
|
|
|
|
|
|
|
|
for (i = level; i < BTRFS_MAX_LEVEL; i++) {
|
|
|
|
|
if (!path->nodes[i])
|
|
|
|
|
break;
|
|
|
|
|
if (!path->locks[i])
|
|
|
|
|
break;
|
2008-06-25 16:01:30 -04:00
|
|
|
if (!no_skips && path->slots[i] == 0) {
|
2008-06-25 16:01:30 -04:00
|
|
|
skip_level = i + 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2008-06-25 16:01:30 -04:00
|
|
|
if (!no_skips && path->keep_locks) {
|
2008-06-25 16:01:30 -04:00
|
|
|
u32 nritems;
|
|
|
|
|
t = path->nodes[i];
|
|
|
|
|
nritems = btrfs_header_nritems(t);
|
2008-06-25 16:01:30 -04:00
|
|
|
if (nritems < 1 || path->slots[i] >= nritems - 1) {
|
2008-06-25 16:01:30 -04:00
|
|
|
skip_level = i + 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-06-25 16:01:30 -04:00
|
|
|
if (skip_level < i && i >= lowest_unlock)
|
|
|
|
|
no_skips = 1;
|
|
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
t = path->nodes[i];
|
|
|
|
|
if (i >= lowest_unlock && i > skip_level && path->locks[i]) {
|
|
|
|
|
btrfs_tree_unlock(t);
|
|
|
|
|
path->locks[i] = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
/*
|
|
|
|
|
* This releases any locks held in the path starting at level and
|
|
|
|
|
* going all the way up to the root.
|
|
|
|
|
*
|
|
|
|
|
* btrfs_search_slot will keep the lock held on higher nodes in a few
|
|
|
|
|
* corner cases, such as COW of the block at slot zero in the node. This
|
|
|
|
|
* ignores those rules, and it should only be called when there are no
|
|
|
|
|
* more updates to be done higher up in the tree.
|
|
|
|
|
*/
|
|
|
|
|
noinline void btrfs_unlock_up_safe(struct btrfs_path *path, int level)
|
|
|
|
|
{
|
|
|
|
|
int 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 10:45:14 -04:00
|
|
|
if (path->keep_locks)
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
for (i = level; i < BTRFS_MAX_LEVEL; i++) {
|
|
|
|
|
if (!path->nodes[i])
|
2009-02-04 09:31:42 -05:00
|
|
|
continue;
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
if (!path->locks[i])
|
2009-02-04 09:31:42 -05:00
|
|
|
continue;
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_tree_unlock(path->nodes[i]);
|
|
|
|
|
path->locks[i] = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-04-03 10:14:18 -04:00
|
|
|
/*
|
|
|
|
|
* helper function for btrfs_search_slot. The goal is to find a block
|
|
|
|
|
* in cache without setting the path to blocking. If we find the block
|
|
|
|
|
* we return zero and the path is unchanged.
|
|
|
|
|
*
|
|
|
|
|
* If we can't find the block, we set the path blocking and do some
|
|
|
|
|
* reada. -EAGAIN is returned and the search must be repeated.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
read_block_for_search(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root, struct btrfs_path *p,
|
|
|
|
|
struct extent_buffer **eb_ret, int level, int slot,
|
|
|
|
|
struct btrfs_key *key)
|
|
|
|
|
{
|
|
|
|
|
u64 blocknr;
|
|
|
|
|
u64 gen;
|
|
|
|
|
u32 blocksize;
|
|
|
|
|
struct extent_buffer *b = *eb_ret;
|
|
|
|
|
struct extent_buffer *tmp;
|
2009-05-14 13:24:30 -04:00
|
|
|
int ret;
|
2009-04-03 10:14:18 -04:00
|
|
|
|
|
|
|
|
blocknr = btrfs_node_blockptr(b, slot);
|
|
|
|
|
gen = btrfs_node_ptr_generation(b, slot);
|
|
|
|
|
blocksize = btrfs_level_size(root, level - 1);
|
|
|
|
|
|
|
|
|
|
tmp = btrfs_find_tree_block(root, blocknr, blocksize);
|
|
|
|
|
if (tmp && btrfs_buffer_uptodate(tmp, gen)) {
|
2009-05-14 13:24:30 -04:00
|
|
|
/*
|
|
|
|
|
* we found an up to date block without sleeping, return
|
|
|
|
|
* right away
|
|
|
|
|
*/
|
2009-04-03 10:14:18 -04:00
|
|
|
*eb_ret = tmp;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* reduce lock contention at high levels
|
|
|
|
|
* of the btree by dropping locks before
|
2009-05-14 13:24:30 -04:00
|
|
|
* we read. Don't release the lock on the current
|
|
|
|
|
* level because we need to walk this node to figure
|
|
|
|
|
* out which blocks to read.
|
2009-04-03 10:14:18 -04:00
|
|
|
*/
|
2009-04-20 15:50:10 -04:00
|
|
|
btrfs_unlock_up_safe(p, level + 1);
|
|
|
|
|
btrfs_set_path_blocking(p);
|
|
|
|
|
|
2009-04-03 10:14:18 -04:00
|
|
|
if (tmp)
|
|
|
|
|
free_extent_buffer(tmp);
|
|
|
|
|
if (p->reada)
|
|
|
|
|
reada_for_search(root, p, level, slot, key->objectid);
|
|
|
|
|
|
2009-04-20 15:50:10 -04:00
|
|
|
btrfs_release_path(NULL, p);
|
2009-05-14 13:24:30 -04:00
|
|
|
|
|
|
|
|
ret = -EAGAIN;
|
2009-04-03 10:14:18 -04:00
|
|
|
tmp = read_tree_block(root, blocknr, blocksize, gen);
|
2009-05-14 13:24:30 -04:00
|
|
|
if (tmp) {
|
|
|
|
|
/*
|
|
|
|
|
* If the read above didn't mark this buffer up to date,
|
|
|
|
|
* it will never end up being up to date. Set ret to EIO now
|
|
|
|
|
* and give up so that our caller doesn't loop forever
|
|
|
|
|
* on our EAGAINs.
|
|
|
|
|
*/
|
|
|
|
|
if (!btrfs_buffer_uptodate(tmp, 0))
|
|
|
|
|
ret = -EIO;
|
2009-04-03 10:14:18 -04:00
|
|
|
free_extent_buffer(tmp);
|
2009-05-14 13:24:30 -04:00
|
|
|
}
|
|
|
|
|
return ret;
|
2009-04-03 10:14:18 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* helper function for btrfs_search_slot. This does all of the checks
|
|
|
|
|
* for node-level blocks and does any balancing required based on
|
|
|
|
|
* the ins_len.
|
|
|
|
|
*
|
|
|
|
|
* If no extra work was required, zero is returned. If we had to
|
|
|
|
|
* drop the path, -EAGAIN is returned and btrfs_search_slot must
|
|
|
|
|
* start over
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
setup_nodes_for_search(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root, struct btrfs_path *p,
|
|
|
|
|
struct extent_buffer *b, int level, int ins_len)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
if ((p->search_for_split || ins_len > 0) && btrfs_header_nritems(b) >=
|
|
|
|
|
BTRFS_NODEPTRS_PER_BLOCK(root) - 3) {
|
|
|
|
|
int sret;
|
|
|
|
|
|
|
|
|
|
sret = reada_for_balance(root, p, level);
|
|
|
|
|
if (sret)
|
|
|
|
|
goto again;
|
|
|
|
|
|
|
|
|
|
btrfs_set_path_blocking(p);
|
|
|
|
|
sret = split_node(trans, root, p, level);
|
|
|
|
|
btrfs_clear_path_blocking(p, NULL);
|
|
|
|
|
|
|
|
|
|
BUG_ON(sret > 0);
|
|
|
|
|
if (sret) {
|
|
|
|
|
ret = sret;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
b = p->nodes[level];
|
|
|
|
|
} else if (ins_len < 0 && btrfs_header_nritems(b) <
|
2009-05-18 10:41:58 -04:00
|
|
|
BTRFS_NODEPTRS_PER_BLOCK(root) / 2) {
|
2009-04-03 10:14:18 -04:00
|
|
|
int sret;
|
|
|
|
|
|
|
|
|
|
sret = reada_for_balance(root, p, level);
|
|
|
|
|
if (sret)
|
|
|
|
|
goto again;
|
|
|
|
|
|
|
|
|
|
btrfs_set_path_blocking(p);
|
|
|
|
|
sret = balance_level(trans, root, p, level);
|
|
|
|
|
btrfs_clear_path_blocking(p, NULL);
|
|
|
|
|
|
|
|
|
|
if (sret) {
|
|
|
|
|
ret = sret;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
b = p->nodes[level];
|
|
|
|
|
if (!b) {
|
|
|
|
|
btrfs_release_path(NULL, p);
|
|
|
|
|
goto again;
|
|
|
|
|
}
|
|
|
|
|
BUG_ON(btrfs_header_nritems(b) == 1);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
again:
|
|
|
|
|
ret = -EAGAIN;
|
|
|
|
|
done:
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/*
|
|
|
|
|
* look for key in the tree. path is filled in with nodes along the way
|
|
|
|
|
* if key is found, we return zero and you can find the item in the leaf
|
|
|
|
|
* level of the path (level 0)
|
|
|
|
|
*
|
|
|
|
|
* If the key isn't found, the path points to the slot where it should
|
2007-02-28 16:35:06 -05:00
|
|
|
* be inserted, and 1 is returned. If there are other errors during the
|
|
|
|
|
* search a negative error number is returned.
|
2007-02-24 13:39:08 -05:00
|
|
|
*
|
|
|
|
|
* if ins_len > 0, nodes and leaves will be split as we walk down the
|
|
|
|
|
* tree. if ins_len < 0, nodes will be merged as we walk down the tree (if
|
|
|
|
|
* possible)
|
2007-02-02 11:05:29 -05:00
|
|
|
*/
|
2007-03-16 16:20:31 -04:00
|
|
|
int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
|
|
|
|
|
*root, struct btrfs_key *key, struct btrfs_path *p, int
|
|
|
|
|
ins_len, int cow)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *b;
|
2007-01-26 15:51:26 -05:00
|
|
|
int slot;
|
|
|
|
|
int ret;
|
2009-07-22 09:59:00 -04:00
|
|
|
int err;
|
2007-01-26 15:51:26 -05:00
|
|
|
int level;
|
2008-06-25 16:01:30 -04:00
|
|
|
int lowest_unlock = 1;
|
2007-08-07 15:52:19 -04:00
|
|
|
u8 lowest_level = 0;
|
|
|
|
|
|
2007-08-07 16:15:09 -04:00
|
|
|
lowest_level = p->lowest_level;
|
2008-10-01 19:05:46 -04:00
|
|
|
WARN_ON(lowest_level && ins_len > 0);
|
2007-03-30 08:47:31 -04:00
|
|
|
WARN_ON(p->nodes[0] != NULL);
|
Btrfs: nuke fs wide allocation mutex V2
This patch removes the giant fs_info->alloc_mutex and replaces it with a bunch
of little locks.
There is now a pinned_mutex, which is used when messing with the pinned_extents
extent io tree, and the extent_ins_mutex which is used with the pending_del and
extent_ins extent io trees.
The locking for the extent tree stuff was inspired by a patch that Yan Zheng
wrote to fix a race condition, I cleaned it up some and changed the locking
around a little bit, but the idea remains the same. Basically instead of
holding the extent_ins_mutex throughout the processing of an extent on the
extent_ins or pending_del trees, we just hold it while we're searching and when
we clear the bits on those trees, and lock the extent for the duration of the
operations on the extent.
Also to keep from getting hung up waiting to lock an extent, I've added a
try_lock_extent so if we cannot lock the extent, move on to the next one in the
tree and we'll come back to that one. I have tested this heavily and it does
not appear to break anything. This has to be applied on top of my
find_free_extent redo patch.
I tested this patch on top of Yan's space reblancing code and it worked fine.
The only thing that has changed since the last version is I pulled out all my
debugging stuff, apparently I forgot to run guilt refresh before I sent the
last patch out. Thank you,
Signed-off-by: Josef Bacik <jbacik@redhat.com>
2008-10-29 14:49:05 -04:00
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
if (ins_len < 0)
|
|
|
|
|
lowest_unlock = 2;
|
2008-08-01 15:11:20 -04:00
|
|
|
|
2007-03-01 12:04:21 -05:00
|
|
|
again:
|
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 10:45:14 -04:00
|
|
|
if (p->search_commit_root) {
|
|
|
|
|
b = root->commit_root;
|
|
|
|
|
extent_buffer_get(b);
|
|
|
|
|
if (!p->skip_locking)
|
|
|
|
|
btrfs_tree_lock(b);
|
|
|
|
|
} else {
|
|
|
|
|
if (p->skip_locking)
|
|
|
|
|
b = btrfs_root_node(root);
|
|
|
|
|
else
|
|
|
|
|
b = btrfs_lock_root_node(root);
|
|
|
|
|
}
|
2008-06-25 16:01:30 -04:00
|
|
|
|
2007-02-02 09:18:22 -05:00
|
|
|
while (b) {
|
2007-10-15 16:14:19 -04:00
|
|
|
level = btrfs_header_level(b);
|
2008-08-01 15:11:20 -04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* setup the path here so we can release it under lock
|
|
|
|
|
* contention with the cow code
|
|
|
|
|
*/
|
|
|
|
|
p->nodes[level] = b;
|
|
|
|
|
if (!p->skip_locking)
|
|
|
|
|
p->locks[level] = 1;
|
|
|
|
|
|
2007-03-02 16:08:05 -05:00
|
|
|
if (cow) {
|
2009-04-03 10:14:18 -04:00
|
|
|
/*
|
|
|
|
|
* if we don't really need to cow this block
|
|
|
|
|
* then we don't want to set the path blocking,
|
|
|
|
|
* so we test it here
|
|
|
|
|
*/
|
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 10:45:14 -04:00
|
|
|
if (!should_cow_block(trans, root, b))
|
2008-08-01 15:11:20 -04:00
|
|
|
goto cow_done;
|
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 10:45:14 -04:00
|
|
|
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_path_blocking(p);
|
|
|
|
|
|
2009-07-22 09:59:00 -04:00
|
|
|
err = btrfs_cow_block(trans, root, b,
|
|
|
|
|
p->nodes[level + 1],
|
|
|
|
|
p->slots[level + 1], &b);
|
|
|
|
|
if (err) {
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(b);
|
2009-07-22 09:59:00 -04:00
|
|
|
ret = err;
|
2008-08-01 15:11:20 -04:00
|
|
|
goto done;
|
2007-06-22 14:16:25 -04:00
|
|
|
}
|
2007-03-02 16:08:05 -05:00
|
|
|
}
|
2008-08-01 15:11:20 -04:00
|
|
|
cow_done:
|
2007-03-02 16:08:05 -05:00
|
|
|
BUG_ON(!cow && ins_len);
|
2007-10-15 16:14:19 -04:00
|
|
|
if (level != btrfs_header_level(b))
|
2007-04-02 10:50:19 -04:00
|
|
|
WARN_ON(1);
|
2007-10-15 16:14:19 -04:00
|
|
|
level = btrfs_header_level(b);
|
2008-08-01 15:11:20 -04:00
|
|
|
|
2007-02-02 09:18:22 -05:00
|
|
|
p->nodes[level] = b;
|
2008-06-25 16:01:30 -04:00
|
|
|
if (!p->skip_locking)
|
|
|
|
|
p->locks[level] = 1;
|
2008-08-01 15:11:20 -04:00
|
|
|
|
2009-02-12 14:09:45 -05:00
|
|
|
btrfs_clear_path_blocking(p, NULL);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* we have a lock on b and as long as we aren't changing
|
|
|
|
|
* the tree, there is no way to for the items in b to change.
|
|
|
|
|
* It is safe to drop the lock on our parent before we
|
|
|
|
|
* go through the expensive btree search on b.
|
|
|
|
|
*
|
|
|
|
|
* If cow is true, then we might be changing slot zero,
|
|
|
|
|
* which may require changing the parent. So, we can't
|
|
|
|
|
* drop the lock until after we know which slot we're
|
|
|
|
|
* operating on.
|
|
|
|
|
*/
|
|
|
|
|
if (!cow)
|
|
|
|
|
btrfs_unlock_up_safe(p, level + 1);
|
|
|
|
|
|
2007-03-14 14:14:43 -04:00
|
|
|
ret = check_block(root, p, level);
|
2008-08-01 15:11:20 -04:00
|
|
|
if (ret) {
|
|
|
|
|
ret = -1;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
2008-06-25 16:01:30 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
ret = bin_search(b, key, level, &slot);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
if (level != 0) {
|
2009-07-22 09:59:00 -04:00
|
|
|
int dec = 0;
|
|
|
|
|
if (ret && slot > 0) {
|
|
|
|
|
dec = 1;
|
2007-01-26 15:51:26 -05:00
|
|
|
slot -= 1;
|
2009-07-22 09:59:00 -04:00
|
|
|
}
|
2007-01-26 15:51:26 -05:00
|
|
|
p->slots[level] = slot;
|
2009-07-22 09:59:00 -04:00
|
|
|
err = setup_nodes_for_search(trans, root, p, b, level,
|
2009-04-03 10:14:18 -04:00
|
|
|
ins_len);
|
2009-07-22 09:59:00 -04:00
|
|
|
if (err == -EAGAIN)
|
2009-04-03 10:14:18 -04:00
|
|
|
goto again;
|
2009-07-22 09:59:00 -04:00
|
|
|
if (err) {
|
|
|
|
|
ret = err;
|
2009-04-03 10:14:18 -04:00
|
|
|
goto done;
|
2009-07-22 09:59:00 -04:00
|
|
|
}
|
2009-04-03 10:14:18 -04:00
|
|
|
b = p->nodes[level];
|
|
|
|
|
slot = p->slots[level];
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
|
2008-06-25 16:14:04 -04:00
|
|
|
unlock_up(p, level, lowest_unlock);
|
|
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
if (level == lowest_level) {
|
2009-07-22 09:59:00 -04:00
|
|
|
if (dec)
|
|
|
|
|
p->slots[level]++;
|
2008-09-26 10:05:38 -04:00
|
|
|
goto done;
|
2008-06-25 16:01:30 -04:00
|
|
|
}
|
2008-05-12 12:59:19 -04:00
|
|
|
|
2009-07-22 09:59:00 -04:00
|
|
|
err = read_block_for_search(trans, root, p,
|
2009-04-03 10:14:18 -04:00
|
|
|
&b, level, slot, key);
|
2009-07-22 09:59:00 -04:00
|
|
|
if (err == -EAGAIN)
|
2009-04-03 10:14:18 -04:00
|
|
|
goto again;
|
2009-07-22 09:59:00 -04:00
|
|
|
if (err) {
|
|
|
|
|
ret = err;
|
2009-05-14 13:24:30 -04:00
|
|
|
goto done;
|
2009-07-22 09:59:00 -04:00
|
|
|
}
|
2009-05-14 13:24:30 -04:00
|
|
|
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
if (!p->skip_locking) {
|
2009-02-12 14:09:45 -05:00
|
|
|
btrfs_clear_path_blocking(p, NULL);
|
2009-07-22 09:59:00 -04:00
|
|
|
err = btrfs_try_spin_lock(b);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
|
2009-07-22 09:59:00 -04:00
|
|
|
if (!err) {
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_path_blocking(p);
|
|
|
|
|
btrfs_tree_lock(b);
|
2009-02-12 14:09:45 -05:00
|
|
|
btrfs_clear_path_blocking(p, b);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
}
|
|
|
|
|
}
|
2007-01-26 15:51:26 -05:00
|
|
|
} else {
|
|
|
|
|
p->slots[level] = slot;
|
2008-12-17 10:21:48 -05:00
|
|
|
if (ins_len > 0 &&
|
|
|
|
|
btrfs_leaf_free_space(root, b) < ins_len) {
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_path_blocking(p);
|
2009-07-22 09:59:00 -04:00
|
|
|
err = split_leaf(trans, root, key,
|
|
|
|
|
p, ins_len, ret == 0);
|
2009-02-12 14:09:45 -05:00
|
|
|
btrfs_clear_path_blocking(p, NULL);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
|
2009-07-22 09:59:00 -04:00
|
|
|
BUG_ON(err > 0);
|
|
|
|
|
if (err) {
|
|
|
|
|
ret = err;
|
2008-08-01 15:11:20 -04:00
|
|
|
goto done;
|
|
|
|
|
}
|
2007-02-22 11:39:13 -05:00
|
|
|
}
|
2008-12-10 09:10:46 -05:00
|
|
|
if (!p->search_for_split)
|
|
|
|
|
unlock_up(p, level, lowest_unlock);
|
2008-08-01 15:11:20 -04:00
|
|
|
goto done;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
}
|
2008-08-01 15:11:20 -04:00
|
|
|
ret = 1;
|
|
|
|
|
done:
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
/*
|
|
|
|
|
* we don't really know what they plan on doing with the path
|
|
|
|
|
* from here on, so for now just mark it as blocking
|
|
|
|
|
*/
|
2009-03-13 11:00:37 -04:00
|
|
|
if (!p->leave_spinning)
|
|
|
|
|
btrfs_set_path_blocking(p);
|
2009-05-14 13:24:30 -04:00
|
|
|
if (ret < 0)
|
|
|
|
|
btrfs_release_path(root, p);
|
2008-08-01 15:11:20 -04:00
|
|
|
return ret;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/*
|
|
|
|
|
* adjust the pointers going up the tree, starting at level
|
|
|
|
|
* making sure the right key of each node is points to 'key'.
|
|
|
|
|
* This is used after shifting pointers to the left, so it stops
|
|
|
|
|
* fixing up pointers when a given leaf/node is not in slot 0 of the
|
|
|
|
|
* higher levels
|
2007-02-28 16:35:06 -05:00
|
|
|
*
|
|
|
|
|
* If this fails to write a tree block, it returns -1, but continues
|
|
|
|
|
* fixing up the blocks in ram so the tree is consistent.
|
2007-02-02 11:05:29 -05:00
|
|
|
*/
|
2007-10-15 16:14:19 -04:00
|
|
|
static int fixup_low_keys(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root, struct btrfs_path *path,
|
|
|
|
|
struct btrfs_disk_key *key, int level)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
|
|
|
|
int i;
|
2007-02-28 16:35:06 -05:00
|
|
|
int ret = 0;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *t;
|
|
|
|
|
|
2007-03-13 10:46:10 -04:00
|
|
|
for (i = level; i < BTRFS_MAX_LEVEL; i++) {
|
2007-01-26 15:51:26 -05:00
|
|
|
int tslot = path->slots[i];
|
2007-02-02 09:18:22 -05:00
|
|
|
if (!path->nodes[i])
|
2007-01-26 15:51:26 -05:00
|
|
|
break;
|
2007-10-15 16:14:19 -04:00
|
|
|
t = path->nodes[i];
|
|
|
|
|
btrfs_set_node_key(t, key, tslot);
|
2007-03-30 14:27:56 -04:00
|
|
|
btrfs_mark_buffer_dirty(path->nodes[i]);
|
2007-01-26 15:51:26 -05:00
|
|
|
if (tslot != 0)
|
|
|
|
|
break;
|
|
|
|
|
}
|
2007-02-28 16:35:06 -05:00
|
|
|
return ret;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
|
2008-09-23 13:14:14 -04:00
|
|
|
/*
|
|
|
|
|
* update item key.
|
|
|
|
|
*
|
|
|
|
|
* This function isn't completely safe. It's the caller's responsibility
|
|
|
|
|
* that the new key won't break the order
|
|
|
|
|
*/
|
|
|
|
|
int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root, struct btrfs_path *path,
|
|
|
|
|
struct btrfs_key *new_key)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_disk_key disk_key;
|
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
|
int slot;
|
|
|
|
|
|
|
|
|
|
eb = path->nodes[0];
|
|
|
|
|
slot = path->slots[0];
|
|
|
|
|
if (slot > 0) {
|
|
|
|
|
btrfs_item_key(eb, &disk_key, slot - 1);
|
|
|
|
|
if (comp_keys(&disk_key, new_key) >= 0)
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
if (slot < btrfs_header_nritems(eb) - 1) {
|
|
|
|
|
btrfs_item_key(eb, &disk_key, slot + 1);
|
|
|
|
|
if (comp_keys(&disk_key, new_key) <= 0)
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
btrfs_cpu_key_to_disk(&disk_key, new_key);
|
|
|
|
|
btrfs_set_item_key(eb, &disk_key, slot);
|
|
|
|
|
btrfs_mark_buffer_dirty(eb);
|
|
|
|
|
if (slot == 0)
|
|
|
|
|
fixup_low_keys(trans, root, path, &disk_key, 1);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/*
|
|
|
|
|
* try to push data from one node into the next node left in the
|
2007-03-01 15:16:26 -05:00
|
|
|
* tree.
|
2007-02-28 16:35:06 -05:00
|
|
|
*
|
|
|
|
|
* returns 0 if some ptrs were pushed left, < 0 if there was some horrible
|
|
|
|
|
* error, and > 0 if there was no room in the left hand block.
|
2007-02-02 11:05:29 -05:00
|
|
|
*/
|
2008-01-03 10:01:48 -05:00
|
|
|
static int push_node_left(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root, struct extent_buffer *dst,
|
2008-04-24 10:54:32 -04:00
|
|
|
struct extent_buffer *src, int empty)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
|
|
|
|
int push_items = 0;
|
2007-03-01 12:04:21 -05:00
|
|
|
int src_nritems;
|
|
|
|
|
int dst_nritems;
|
2007-02-28 16:35:06 -05:00
|
|
|
int ret = 0;
|
2007-01-26 15:51:26 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
src_nritems = btrfs_header_nritems(src);
|
|
|
|
|
dst_nritems = btrfs_header_nritems(dst);
|
2007-03-14 14:14:43 -04:00
|
|
|
push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
|
2007-12-11 09:25:06 -05:00
|
|
|
WARN_ON(btrfs_header_generation(src) != trans->transid);
|
|
|
|
|
WARN_ON(btrfs_header_generation(dst) != trans->transid);
|
2007-06-22 14:16:25 -04:00
|
|
|
|
2008-04-24 14:42:46 -04:00
|
|
|
if (!empty && src_nritems <= 8)
|
2008-04-24 10:54:32 -04:00
|
|
|
return 1;
|
|
|
|
|
|
2009-01-05 21:25:51 -05:00
|
|
|
if (push_items <= 0)
|
2007-01-26 15:51:26 -05:00
|
|
|
return 1;
|
|
|
|
|
|
2008-04-24 14:42:46 -04:00
|
|
|
if (empty) {
|
2008-04-24 10:54:32 -04:00
|
|
|
push_items = min(src_nritems, push_items);
|
2008-04-24 14:42:46 -04:00
|
|
|
if (push_items < src_nritems) {
|
|
|
|
|
/* leave at least 8 pointers in the node if
|
|
|
|
|
* we aren't going to empty it
|
|
|
|
|
*/
|
|
|
|
|
if (src_nritems - push_items < 8) {
|
|
|
|
|
if (push_items <= 8)
|
|
|
|
|
return 1;
|
|
|
|
|
push_items -= 8;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
push_items = min(src_nritems - 8, push_items);
|
2007-03-01 15:16:26 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
copy_extent_buffer(dst, src,
|
|
|
|
|
btrfs_node_key_ptr_offset(dst_nritems),
|
|
|
|
|
btrfs_node_key_ptr_offset(0),
|
2009-01-05 21:25:51 -05:00
|
|
|
push_items * sizeof(struct btrfs_key_ptr));
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2007-03-01 12:04:21 -05:00
|
|
|
if (push_items < src_nritems) {
|
2007-10-15 16:14:19 -04:00
|
|
|
memmove_extent_buffer(src, btrfs_node_key_ptr_offset(0),
|
|
|
|
|
btrfs_node_key_ptr_offset(push_items),
|
|
|
|
|
(src_nritems - push_items) *
|
|
|
|
|
sizeof(struct btrfs_key_ptr));
|
|
|
|
|
}
|
|
|
|
|
btrfs_set_header_nritems(src, src_nritems - push_items);
|
|
|
|
|
btrfs_set_header_nritems(dst, dst_nritems + push_items);
|
|
|
|
|
btrfs_mark_buffer_dirty(src);
|
|
|
|
|
btrfs_mark_buffer_dirty(dst);
|
2008-09-23 13:14:14 -04:00
|
|
|
|
2007-03-01 15:16:26 -05:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* try to push data from one node into the next node right in the
|
|
|
|
|
* tree.
|
|
|
|
|
*
|
|
|
|
|
* returns 0 if some ptrs were pushed, < 0 if there was some horrible
|
|
|
|
|
* error, and > 0 if there was no room in the right hand block.
|
|
|
|
|
*
|
|
|
|
|
* this will only push up to 1/2 the contents of the left node over
|
|
|
|
|
*/
|
2007-10-15 16:14:19 -04:00
|
|
|
static int balance_node_right(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct extent_buffer *dst,
|
|
|
|
|
struct extent_buffer *src)
|
2007-03-01 15:16:26 -05:00
|
|
|
{
|
|
|
|
|
int push_items = 0;
|
|
|
|
|
int max_push;
|
|
|
|
|
int src_nritems;
|
|
|
|
|
int dst_nritems;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
2007-12-11 09:25:06 -05:00
|
|
|
WARN_ON(btrfs_header_generation(src) != trans->transid);
|
|
|
|
|
WARN_ON(btrfs_header_generation(dst) != trans->transid);
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
src_nritems = btrfs_header_nritems(src);
|
|
|
|
|
dst_nritems = btrfs_header_nritems(dst);
|
2007-03-14 14:14:43 -04:00
|
|
|
push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
|
2009-01-05 21:25:51 -05:00
|
|
|
if (push_items <= 0)
|
2007-03-01 15:16:26 -05:00
|
|
|
return 1;
|
2008-04-24 14:42:46 -04:00
|
|
|
|
2009-01-05 21:25:51 -05:00
|
|
|
if (src_nritems < 4)
|
2008-04-24 14:42:46 -04:00
|
|
|
return 1;
|
2007-03-01 15:16:26 -05:00
|
|
|
|
|
|
|
|
max_push = src_nritems / 2 + 1;
|
|
|
|
|
/* don't try to empty the node */
|
2009-01-05 21:25:51 -05:00
|
|
|
if (max_push >= src_nritems)
|
2007-03-01 15:16:26 -05:00
|
|
|
return 1;
|
2007-08-29 09:11:44 -04:00
|
|
|
|
2007-03-01 15:16:26 -05:00
|
|
|
if (max_push < push_items)
|
|
|
|
|
push_items = max_push;
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
memmove_extent_buffer(dst, btrfs_node_key_ptr_offset(push_items),
|
|
|
|
|
btrfs_node_key_ptr_offset(0),
|
|
|
|
|
(dst_nritems) *
|
|
|
|
|
sizeof(struct btrfs_key_ptr));
|
2007-03-30 14:27:56 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
copy_extent_buffer(dst, src,
|
|
|
|
|
btrfs_node_key_ptr_offset(0),
|
|
|
|
|
btrfs_node_key_ptr_offset(src_nritems - push_items),
|
2009-01-05 21:25:51 -05:00
|
|
|
push_items * sizeof(struct btrfs_key_ptr));
|
2007-03-01 15:16:26 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_nritems(src, src_nritems - push_items);
|
|
|
|
|
btrfs_set_header_nritems(dst, dst_nritems + push_items);
|
2007-03-01 15:16:26 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_mark_buffer_dirty(src);
|
|
|
|
|
btrfs_mark_buffer_dirty(dst);
|
2008-09-23 13:14:14 -04:00
|
|
|
|
2007-02-28 16:35:06 -05:00
|
|
|
return ret;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
|
2007-02-24 13:39:08 -05:00
|
|
|
/*
|
|
|
|
|
* helper function to insert a new root level in the tree.
|
|
|
|
|
* A new node is allocated, and a single item is inserted to
|
|
|
|
|
* point to the existing root
|
2007-02-28 16:35:06 -05:00
|
|
|
*
|
|
|
|
|
* returns zero on success or < 0 on failure.
|
2007-02-24 13:39:08 -05:00
|
|
|
*/
|
2009-01-05 21:25:51 -05:00
|
|
|
static noinline int insert_new_root(struct btrfs_trans_handle *trans,
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path, int level)
|
2007-02-22 11:39:13 -05:00
|
|
|
{
|
2007-12-11 09:25:06 -05:00
|
|
|
u64 lower_gen;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *lower;
|
|
|
|
|
struct extent_buffer *c;
|
2008-06-25 16:01:30 -04:00
|
|
|
struct extent_buffer *old;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_disk_key lower_key;
|
2007-02-22 11:39:13 -05:00
|
|
|
|
|
|
|
|
BUG_ON(path->nodes[level]);
|
|
|
|
|
BUG_ON(path->nodes[level-1] != root->node);
|
|
|
|
|
|
2007-12-11 09:25:06 -05:00
|
|
|
lower = path->nodes[level-1];
|
|
|
|
|
if (level == 1)
|
|
|
|
|
btrfs_item_key(lower, &lower_key, 0);
|
|
|
|
|
else
|
|
|
|
|
btrfs_node_key(lower, &lower_key, 0);
|
|
|
|
|
|
2008-09-23 13:14:14 -04:00
|
|
|
c = btrfs_alloc_free_block(trans, root, root->nodesize, 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 10:45:14 -04:00
|
|
|
root->root_key.objectid, &lower_key,
|
2008-09-05 16:43:28 -04:00
|
|
|
level, root->node->start, 0);
|
2007-10-15 16:14:19 -04:00
|
|
|
if (IS_ERR(c))
|
|
|
|
|
return PTR_ERR(c);
|
2008-06-25 16:01:30 -04: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 10:45:14 -04:00
|
|
|
memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_nritems(c, 1);
|
|
|
|
|
btrfs_set_header_level(c, level);
|
2007-10-15 16:15:53 -04:00
|
|
|
btrfs_set_header_bytenr(c, c->start);
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_generation(c, trans->transid);
|
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 10:45:14 -04:00
|
|
|
btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_owner(c, root->root_key.objectid);
|
|
|
|
|
|
|
|
|
|
write_extent_buffer(c, root->fs_info->fsid,
|
|
|
|
|
(unsigned long)btrfs_header_fsid(c),
|
|
|
|
|
BTRFS_FSID_SIZE);
|
2008-04-15 15:41:47 -04:00
|
|
|
|
|
|
|
|
write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
|
|
|
|
|
(unsigned long)btrfs_header_chunk_tree_uuid(c),
|
|
|
|
|
BTRFS_UUID_SIZE);
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_node_key(c, &lower_key, 0);
|
2007-10-15 16:15:53 -04:00
|
|
|
btrfs_set_node_blockptr(c, 0, lower->start);
|
2007-12-11 09:25:06 -05:00
|
|
|
lower_gen = btrfs_header_generation(lower);
|
2008-09-23 13:14:14 -04:00
|
|
|
WARN_ON(lower_gen != trans->transid);
|
2007-12-11 09:25:06 -05:00
|
|
|
|
|
|
|
|
btrfs_set_node_ptr_generation(c, 0, lower_gen);
|
2007-03-23 10:01:08 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_mark_buffer_dirty(c);
|
2007-03-23 10:01:08 -04:00
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
spin_lock(&root->node_lock);
|
|
|
|
|
old = root->node;
|
2007-10-15 16:14:19 -04:00
|
|
|
root->node = c;
|
2008-06-25 16:01:30 -04:00
|
|
|
spin_unlock(&root->node_lock);
|
|
|
|
|
|
|
|
|
|
/* the super has an extra ref to root->node */
|
|
|
|
|
free_extent_buffer(old);
|
|
|
|
|
|
2008-03-24 15:01:56 -04:00
|
|
|
add_root_to_dirty_list(root);
|
2007-10-15 16:14:19 -04:00
|
|
|
extent_buffer_get(c);
|
|
|
|
|
path->nodes[level] = c;
|
2008-06-25 16:01:30 -04:00
|
|
|
path->locks[level] = 1;
|
2007-02-22 11:39:13 -05:00
|
|
|
path->slots[level] = 0;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/*
|
|
|
|
|
* worker function to insert a single pointer in a node.
|
|
|
|
|
* the node should have enough room for the pointer already
|
2007-02-24 13:39:08 -05:00
|
|
|
*
|
2007-02-02 11:05:29 -05:00
|
|
|
* slot and level indicate where you want the key to go, and
|
|
|
|
|
* blocknr is the block the key points to.
|
2007-02-28 16:35:06 -05:00
|
|
|
*
|
|
|
|
|
* returns zero on success and < 0 on any error
|
2007-02-02 11:05:29 -05:00
|
|
|
*/
|
2007-03-16 16:20:31 -04:00
|
|
|
static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root
|
|
|
|
|
*root, struct btrfs_path *path, struct btrfs_disk_key
|
2007-10-15 16:15:53 -04:00
|
|
|
*key, u64 bytenr, int slot, int level)
|
2007-02-02 11:05:29 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *lower;
|
2007-02-02 11:05:29 -05:00
|
|
|
int nritems;
|
2007-02-22 11:39:13 -05:00
|
|
|
|
|
|
|
|
BUG_ON(!path->nodes[level]);
|
2007-10-15 16:14:19 -04:00
|
|
|
lower = path->nodes[level];
|
|
|
|
|
nritems = btrfs_header_nritems(lower);
|
2009-04-02 17:05:11 -04:00
|
|
|
BUG_ON(slot > nritems);
|
2007-03-14 14:14:43 -04:00
|
|
|
if (nritems == BTRFS_NODEPTRS_PER_BLOCK(root))
|
2007-02-02 11:05:29 -05:00
|
|
|
BUG();
|
|
|
|
|
if (slot != nritems) {
|
2007-10-15 16:14:19 -04:00
|
|
|
memmove_extent_buffer(lower,
|
|
|
|
|
btrfs_node_key_ptr_offset(slot + 1),
|
|
|
|
|
btrfs_node_key_ptr_offset(slot),
|
2007-03-30 14:27:56 -04:00
|
|
|
(nritems - slot) * sizeof(struct btrfs_key_ptr));
|
2007-02-02 11:05:29 -05:00
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_node_key(lower, key, slot);
|
2007-10-15 16:15:53 -04:00
|
|
|
btrfs_set_node_blockptr(lower, slot, bytenr);
|
2007-12-11 09:25:06 -05:00
|
|
|
WARN_ON(trans->transid == 0);
|
|
|
|
|
btrfs_set_node_ptr_generation(lower, slot, trans->transid);
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_nritems(lower, nritems + 1);
|
|
|
|
|
btrfs_mark_buffer_dirty(lower);
|
2007-02-02 11:05:29 -05:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-24 13:39:08 -05:00
|
|
|
/*
|
|
|
|
|
* split the node at the specified level in path in two.
|
|
|
|
|
* The path is corrected to point to the appropriate node after the split
|
|
|
|
|
*
|
|
|
|
|
* Before splitting this tries to make some room in the node by pushing
|
|
|
|
|
* left and right, if either one works, it returns right away.
|
2007-02-28 16:35:06 -05:00
|
|
|
*
|
|
|
|
|
* returns 0 on success and < 0 on failure
|
2007-02-24 13:39:08 -05:00
|
|
|
*/
|
2008-09-05 16:13:11 -04:00
|
|
|
static noinline int split_node(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path, int level)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *c;
|
|
|
|
|
struct extent_buffer *split;
|
|
|
|
|
struct btrfs_disk_key disk_key;
|
2007-01-26 15:51:26 -05:00
|
|
|
int mid;
|
2007-02-22 11:39:13 -05:00
|
|
|
int ret;
|
2007-02-28 16:35:06 -05:00
|
|
|
int wret;
|
2007-03-12 12:01:18 -04:00
|
|
|
u32 c_nritems;
|
2007-02-02 09:18:22 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
c = path->nodes[level];
|
2007-12-11 09:25:06 -05:00
|
|
|
WARN_ON(btrfs_header_generation(c) != trans->transid);
|
2007-10-15 16:14:19 -04:00
|
|
|
if (c == root->node) {
|
2007-02-22 11:39:13 -05:00
|
|
|
/* trying to split the root, lets make a new one */
|
2007-03-16 16:20:31 -04:00
|
|
|
ret = insert_new_root(trans, root, path, level + 1);
|
2007-02-22 11:39:13 -05:00
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
2009-05-13 19:12:15 -04:00
|
|
|
} else {
|
2007-04-20 13:16:02 -04:00
|
|
|
ret = push_nodes_for_insert(trans, root, path, level);
|
2007-10-15 16:14:19 -04:00
|
|
|
c = path->nodes[level];
|
|
|
|
|
if (!ret && btrfs_header_nritems(c) <
|
2008-04-24 09:34:34 -04:00
|
|
|
BTRFS_NODEPTRS_PER_BLOCK(root) - 3)
|
2007-04-20 13:16:02 -04:00
|
|
|
return 0;
|
2007-06-22 14:16:25 -04:00
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
2007-04-20 13:16:02 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
c_nritems = btrfs_header_nritems(c);
|
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 10:45:14 -04:00
|
|
|
mid = (c_nritems + 1) / 2;
|
|
|
|
|
btrfs_node_key(c, &disk_key, mid);
|
2007-12-11 09:25:06 -05: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 10:45:14 -04:00
|
|
|
split = btrfs_alloc_free_block(trans, root, root->nodesize, 0,
|
2008-09-23 13:14:14 -04:00
|
|
|
root->root_key.objectid,
|
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 10:45:14 -04:00
|
|
|
&disk_key, level, c->start, 0);
|
2007-10-15 16:14:19 -04:00
|
|
|
if (IS_ERR(split))
|
|
|
|
|
return PTR_ERR(split);
|
|
|
|
|
|
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 10:45:14 -04:00
|
|
|
memset_extent_buffer(split, 0, 0, sizeof(struct btrfs_header));
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_level(split, btrfs_header_level(c));
|
2007-10-15 16:15:53 -04:00
|
|
|
btrfs_set_header_bytenr(split, split->start);
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_generation(split, trans->transid);
|
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 10:45:14 -04:00
|
|
|
btrfs_set_header_backref_rev(split, BTRFS_MIXED_BACKREF_REV);
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_owner(split, root->root_key.objectid);
|
|
|
|
|
write_extent_buffer(split, root->fs_info->fsid,
|
|
|
|
|
(unsigned long)btrfs_header_fsid(split),
|
|
|
|
|
BTRFS_FSID_SIZE);
|
2008-04-15 15:41:47 -04:00
|
|
|
write_extent_buffer(split, root->fs_info->chunk_tree_uuid,
|
|
|
|
|
(unsigned long)btrfs_header_chunk_tree_uuid(split),
|
|
|
|
|
BTRFS_UUID_SIZE);
|
2007-06-22 14:16:25 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
|
|
|
|
|
copy_extent_buffer(split, c,
|
|
|
|
|
btrfs_node_key_ptr_offset(0),
|
|
|
|
|
btrfs_node_key_ptr_offset(mid),
|
|
|
|
|
(c_nritems - mid) * sizeof(struct btrfs_key_ptr));
|
|
|
|
|
btrfs_set_header_nritems(split, c_nritems - mid);
|
|
|
|
|
btrfs_set_header_nritems(c, mid);
|
2007-02-28 16:35:06 -05:00
|
|
|
ret = 0;
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_mark_buffer_dirty(c);
|
|
|
|
|
btrfs_mark_buffer_dirty(split);
|
|
|
|
|
|
2007-10-15 16:15:53 -04:00
|
|
|
wret = insert_ptr(trans, root, path, &disk_key, split->start,
|
2007-10-15 16:14:19 -04:00
|
|
|
path->slots[level + 1] + 1,
|
2007-03-14 14:14:43 -04:00
|
|
|
level + 1);
|
2007-02-28 16:35:06 -05:00
|
|
|
if (wret)
|
|
|
|
|
ret = wret;
|
|
|
|
|
|
2007-02-24 06:24:44 -05:00
|
|
|
if (path->slots[level] >= mid) {
|
2007-02-22 11:39:13 -05:00
|
|
|
path->slots[level] -= mid;
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(c);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(c);
|
|
|
|
|
path->nodes[level] = split;
|
2007-02-22 11:39:13 -05:00
|
|
|
path->slots[level + 1] += 1;
|
|
|
|
|
} else {
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(split);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(split);
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
2007-02-28 16:35:06 -05:00
|
|
|
return ret;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/*
|
|
|
|
|
* how many bytes are required to store the items in a leaf. start
|
|
|
|
|
* and nr indicate which items in the leaf to check. This totals up the
|
|
|
|
|
* space used both by the item structs and the item data
|
|
|
|
|
*/
|
2007-10-15 16:14:19 -04:00
|
|
|
static int leaf_space_used(struct extent_buffer *l, int start, int nr)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
|
|
|
|
int data_len;
|
2007-10-15 16:14:19 -04:00
|
|
|
int nritems = btrfs_header_nritems(l);
|
2007-04-04 14:08:15 -04:00
|
|
|
int end = min(nritems, start + nr) - 1;
|
2007-01-26 15:51:26 -05:00
|
|
|
|
|
|
|
|
if (!nr)
|
|
|
|
|
return 0;
|
2007-10-15 16:14:19 -04:00
|
|
|
data_len = btrfs_item_end_nr(l, start);
|
|
|
|
|
data_len = data_len - btrfs_item_offset_nr(l, end);
|
2007-03-12 20:12:07 -04:00
|
|
|
data_len += sizeof(struct btrfs_item) * nr;
|
2007-04-04 14:08:15 -04:00
|
|
|
WARN_ON(data_len < 0);
|
2007-01-26 15:51:26 -05:00
|
|
|
return data_len;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-04 14:08:15 -04:00
|
|
|
/*
|
|
|
|
|
* The space between the end of the leaf items and
|
|
|
|
|
* the start of the leaf data. IOW, how much room
|
|
|
|
|
* the leaf has left for both items and data
|
|
|
|
|
*/
|
2009-01-05 21:25:51 -05:00
|
|
|
noinline int btrfs_leaf_free_space(struct btrfs_root *root,
|
2008-09-05 16:13:11 -04:00
|
|
|
struct extent_buffer *leaf)
|
2007-04-04 14:08:15 -04:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
int nritems = btrfs_header_nritems(leaf);
|
|
|
|
|
int ret;
|
|
|
|
|
ret = BTRFS_LEAF_DATA_SIZE(root) - leaf_space_used(leaf, 0, nritems);
|
|
|
|
|
if (ret < 0) {
|
2009-01-05 21:25:51 -05:00
|
|
|
printk(KERN_CRIT "leaf free space ret %d, leaf data size %lu, "
|
|
|
|
|
"used %d nritems %d\n",
|
2007-10-19 09:22:59 -04:00
|
|
|
ret, (unsigned long) BTRFS_LEAF_DATA_SIZE(root),
|
2007-10-15 16:14:19 -04:00
|
|
|
leaf_space_used(leaf, 0, nritems), nritems);
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
2007-04-04 14:08:15 -04:00
|
|
|
}
|
|
|
|
|
|
2009-03-13 10:04:31 -04:00
|
|
|
static noinline int __push_leaf_right(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path,
|
|
|
|
|
int data_size, int empty,
|
|
|
|
|
struct extent_buffer *right,
|
|
|
|
|
int free_space, u32 left_nritems)
|
2007-02-24 12:47:20 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *left = path->nodes[0];
|
2009-03-13 10:04:31 -04:00
|
|
|
struct extent_buffer *upper = path->nodes[1];
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_disk_key disk_key;
|
2007-02-24 12:47:20 -05:00
|
|
|
int slot;
|
2007-11-07 13:31:03 -05:00
|
|
|
u32 i;
|
2007-02-24 12:47:20 -05:00
|
|
|
int push_space = 0;
|
|
|
|
|
int push_items = 0;
|
2007-03-12 20:12:07 -04:00
|
|
|
struct btrfs_item *item;
|
2007-11-07 13:31:03 -05:00
|
|
|
u32 nr;
|
2007-03-12 12:01:18 -04:00
|
|
|
u32 right_nritems;
|
2007-10-15 16:14:19 -04:00
|
|
|
u32 data_end;
|
2007-10-15 16:15:53 -04:00
|
|
|
u32 this_item_size;
|
2007-02-24 12:47:20 -05:00
|
|
|
|
2007-11-07 13:31:03 -05:00
|
|
|
if (empty)
|
|
|
|
|
nr = 0;
|
|
|
|
|
else
|
|
|
|
|
nr = 1;
|
|
|
|
|
|
2008-09-23 13:14:14 -04:00
|
|
|
if (path->slots[0] >= left_nritems)
|
2008-12-17 10:21:48 -05:00
|
|
|
push_space += data_size;
|
2008-09-23 13:14:14 -04:00
|
|
|
|
2009-03-13 10:04:31 -04:00
|
|
|
slot = path->slots[1];
|
2007-11-07 13:31:03 -05:00
|
|
|
i = left_nritems - 1;
|
|
|
|
|
while (i >= nr) {
|
2007-10-15 16:14:19 -04:00
|
|
|
item = btrfs_item_nr(left, i);
|
2007-10-15 16:15:53 -04:00
|
|
|
|
2008-09-23 13:14:14 -04:00
|
|
|
if (!empty && push_items > 0) {
|
|
|
|
|
if (path->slots[0] > i)
|
|
|
|
|
break;
|
|
|
|
|
if (path->slots[0] == i) {
|
|
|
|
|
int space = btrfs_leaf_free_space(root, left);
|
|
|
|
|
if (space + push_space * 2 > free_space)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-24 12:47:20 -05:00
|
|
|
if (path->slots[0] == i)
|
2008-12-17 10:21:48 -05:00
|
|
|
push_space += data_size;
|
2007-10-15 16:15:53 -04:00
|
|
|
|
|
|
|
|
if (!left->map_token) {
|
|
|
|
|
map_extent_buffer(left, (unsigned long)item,
|
|
|
|
|
sizeof(struct btrfs_item),
|
|
|
|
|
&left->map_token, &left->kaddr,
|
|
|
|
|
&left->map_start, &left->map_len,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
this_item_size = btrfs_item_size(left, item);
|
|
|
|
|
if (this_item_size + sizeof(*item) + push_space > free_space)
|
2007-02-24 12:47:20 -05:00
|
|
|
break;
|
2008-09-23 13:14:14 -04:00
|
|
|
|
2007-02-24 12:47:20 -05:00
|
|
|
push_items++;
|
2007-10-15 16:15:53 -04:00
|
|
|
push_space += this_item_size + sizeof(*item);
|
2007-11-07 13:31:03 -05:00
|
|
|
if (i == 0)
|
|
|
|
|
break;
|
|
|
|
|
i--;
|
2007-10-15 16:15:53 -04:00
|
|
|
}
|
|
|
|
|
if (left->map_token) {
|
|
|
|
|
unmap_extent_buffer(left, left->map_token, KM_USER1);
|
|
|
|
|
left->map_token = NULL;
|
2007-02-24 12:47:20 -05:00
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
if (push_items == 0)
|
|
|
|
|
goto out_unlock;
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2007-11-07 13:31:03 -05:00
|
|
|
if (!empty && push_items == left_nritems)
|
2007-04-18 16:15:28 -04:00
|
|
|
WARN_ON(1);
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2007-02-24 12:47:20 -05:00
|
|
|
/* push left to right */
|
2007-10-15 16:14:19 -04:00
|
|
|
right_nritems = btrfs_header_nritems(right);
|
2007-11-07 13:31:03 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
push_space = btrfs_item_end_nr(left, left_nritems - push_items);
|
2007-03-14 14:14:43 -04:00
|
|
|
push_space -= leaf_data_end(root, left);
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2007-02-24 12:47:20 -05:00
|
|
|
/* make room in the right data area */
|
2007-10-15 16:14:19 -04:00
|
|
|
data_end = leaf_data_end(root, right);
|
|
|
|
|
memmove_extent_buffer(right,
|
|
|
|
|
btrfs_leaf_data(right) + data_end - push_space,
|
|
|
|
|
btrfs_leaf_data(right) + data_end,
|
|
|
|
|
BTRFS_LEAF_DATA_SIZE(root) - data_end);
|
|
|
|
|
|
2007-02-24 12:47:20 -05:00
|
|
|
/* copy from the left data area */
|
2007-10-15 16:14:19 -04:00
|
|
|
copy_extent_buffer(right, left, btrfs_leaf_data(right) +
|
2007-03-30 14:27:56 -04:00
|
|
|
BTRFS_LEAF_DATA_SIZE(root) - push_space,
|
|
|
|
|
btrfs_leaf_data(left) + leaf_data_end(root, left),
|
|
|
|
|
push_space);
|
2007-10-15 16:14:19 -04:00
|
|
|
|
|
|
|
|
memmove_extent_buffer(right, btrfs_item_nr_offset(push_items),
|
|
|
|
|
btrfs_item_nr_offset(0),
|
|
|
|
|
right_nritems * sizeof(struct btrfs_item));
|
|
|
|
|
|
2007-02-24 12:47:20 -05:00
|
|
|
/* copy the items from left to right */
|
2007-10-15 16:14:19 -04:00
|
|
|
copy_extent_buffer(right, left, btrfs_item_nr_offset(0),
|
|
|
|
|
btrfs_item_nr_offset(left_nritems - push_items),
|
|
|
|
|
push_items * sizeof(struct btrfs_item));
|
2007-02-24 12:47:20 -05:00
|
|
|
|
|
|
|
|
/* update the item pointers */
|
2007-03-12 12:01:18 -04:00
|
|
|
right_nritems += push_items;
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_nritems(right, right_nritems);
|
2007-03-14 14:14:43 -04:00
|
|
|
push_space = BTRFS_LEAF_DATA_SIZE(root);
|
2007-03-12 12:01:18 -04:00
|
|
|
for (i = 0; i < right_nritems; i++) {
|
2007-10-15 16:14:19 -04:00
|
|
|
item = btrfs_item_nr(right, i);
|
2007-10-15 16:15:53 -04:00
|
|
|
if (!right->map_token) {
|
|
|
|
|
map_extent_buffer(right, (unsigned long)item,
|
|
|
|
|
sizeof(struct btrfs_item),
|
|
|
|
|
&right->map_token, &right->kaddr,
|
|
|
|
|
&right->map_start, &right->map_len,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
}
|
|
|
|
|
push_space -= btrfs_item_size(right, item);
|
|
|
|
|
btrfs_set_item_offset(right, item, push_space);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (right->map_token) {
|
|
|
|
|
unmap_extent_buffer(right, right->map_token, KM_USER1);
|
|
|
|
|
right->map_token = NULL;
|
2007-02-24 12:47:20 -05:00
|
|
|
}
|
2007-03-12 12:01:18 -04:00
|
|
|
left_nritems -= push_items;
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_nritems(left, left_nritems);
|
2007-02-24 12:47:20 -05:00
|
|
|
|
2007-11-07 13:31:03 -05:00
|
|
|
if (left_nritems)
|
|
|
|
|
btrfs_mark_buffer_dirty(left);
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_mark_buffer_dirty(right);
|
2007-04-18 16:15:28 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_item_key(right, &disk_key, 0);
|
|
|
|
|
btrfs_set_node_key(upper, &disk_key, slot + 1);
|
2007-03-30 14:27:56 -04:00
|
|
|
btrfs_mark_buffer_dirty(upper);
|
2007-03-02 16:08:05 -05:00
|
|
|
|
2007-02-24 12:47:20 -05:00
|
|
|
/* then fixup the leaf pointer in the path */
|
2007-03-12 12:01:18 -04:00
|
|
|
if (path->slots[0] >= left_nritems) {
|
|
|
|
|
path->slots[0] -= left_nritems;
|
2008-06-25 16:01:30 -04:00
|
|
|
if (btrfs_header_nritems(path->nodes[0]) == 0)
|
|
|
|
|
clean_tree_block(trans, root, path->nodes[0]);
|
|
|
|
|
btrfs_tree_unlock(path->nodes[0]);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(path->nodes[0]);
|
|
|
|
|
path->nodes[0] = right;
|
2007-02-24 12:47:20 -05:00
|
|
|
path->slots[1] += 1;
|
|
|
|
|
} else {
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(right);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(right);
|
2007-02-24 12:47:20 -05:00
|
|
|
}
|
|
|
|
|
return 0;
|
2008-06-25 16:01:30 -04:00
|
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
|
btrfs_tree_unlock(right);
|
|
|
|
|
free_extent_buffer(right);
|
|
|
|
|
return 1;
|
2007-02-24 12:47:20 -05:00
|
|
|
}
|
2008-06-25 16:01:30 -04:00
|
|
|
|
2009-03-13 10:04:31 -04:00
|
|
|
/*
|
|
|
|
|
* push some data in the path leaf to the right, trying to free up at
|
|
|
|
|
* least data_size bytes. returns zero if the push worked, nonzero otherwise
|
|
|
|
|
*
|
|
|
|
|
* returns 1 if the push failed because the other node didn't have enough
|
|
|
|
|
* room, 0 if everything worked out and < 0 if there were major errors.
|
|
|
|
|
*/
|
|
|
|
|
static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
|
|
|
|
|
*root, struct btrfs_path *path, int data_size,
|
|
|
|
|
int empty)
|
|
|
|
|
{
|
|
|
|
|
struct extent_buffer *left = path->nodes[0];
|
|
|
|
|
struct extent_buffer *right;
|
|
|
|
|
struct extent_buffer *upper;
|
|
|
|
|
int slot;
|
|
|
|
|
int free_space;
|
|
|
|
|
u32 left_nritems;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!path->nodes[1])
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
slot = path->slots[1];
|
|
|
|
|
upper = path->nodes[1];
|
|
|
|
|
if (slot >= btrfs_header_nritems(upper) - 1)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
btrfs_assert_tree_locked(path->nodes[1]);
|
|
|
|
|
|
|
|
|
|
right = read_node_slot(root, upper, slot + 1);
|
|
|
|
|
btrfs_tree_lock(right);
|
|
|
|
|
btrfs_set_lock_blocking(right);
|
|
|
|
|
|
|
|
|
|
free_space = btrfs_leaf_free_space(root, right);
|
|
|
|
|
if (free_space < data_size)
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
|
|
/* cow and double check */
|
|
|
|
|
ret = btrfs_cow_block(trans, root, right, upper,
|
|
|
|
|
slot + 1, &right);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
|
|
free_space = btrfs_leaf_free_space(root, right);
|
|
|
|
|
if (free_space < data_size)
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
|
|
left_nritems = btrfs_header_nritems(left);
|
|
|
|
|
if (left_nritems == 0)
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
|
|
return __push_leaf_right(trans, root, path, data_size, empty,
|
|
|
|
|
right, free_space, left_nritems);
|
|
|
|
|
out_unlock:
|
|
|
|
|
btrfs_tree_unlock(right);
|
|
|
|
|
free_extent_buffer(right);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/*
|
|
|
|
|
* push some data in the path leaf to the left, trying to free up at
|
|
|
|
|
* least data_size bytes. returns zero if the push worked, nonzero otherwise
|
|
|
|
|
*/
|
2009-03-13 10:04:31 -04:00
|
|
|
static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path, int data_size,
|
|
|
|
|
int empty, struct extent_buffer *left,
|
|
|
|
|
int free_space, int right_nritems)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_disk_key disk_key;
|
|
|
|
|
struct extent_buffer *right = path->nodes[0];
|
2007-01-26 15:51:26 -05:00
|
|
|
int slot;
|
|
|
|
|
int i;
|
|
|
|
|
int push_space = 0;
|
|
|
|
|
int push_items = 0;
|
2007-03-12 20:12:07 -04:00
|
|
|
struct btrfs_item *item;
|
2007-03-12 12:01:18 -04:00
|
|
|
u32 old_left_nritems;
|
2007-11-07 13:31:03 -05:00
|
|
|
u32 nr;
|
2007-02-28 16:35:06 -05:00
|
|
|
int ret = 0;
|
|
|
|
|
int wret;
|
2007-10-15 16:15:53 -04:00
|
|
|
u32 this_item_size;
|
|
|
|
|
u32 old_left_item_size;
|
2007-01-26 15:51:26 -05:00
|
|
|
|
|
|
|
|
slot = path->slots[1];
|
2007-03-02 16:08:05 -05:00
|
|
|
|
2007-11-07 13:31:03 -05:00
|
|
|
if (empty)
|
|
|
|
|
nr = right_nritems;
|
|
|
|
|
else
|
|
|
|
|
nr = right_nritems - 1;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nr; i++) {
|
2007-10-15 16:14:19 -04:00
|
|
|
item = btrfs_item_nr(right, i);
|
2007-10-15 16:15:53 -04:00
|
|
|
if (!right->map_token) {
|
|
|
|
|
map_extent_buffer(right, (unsigned long)item,
|
|
|
|
|
sizeof(struct btrfs_item),
|
|
|
|
|
&right->map_token, &right->kaddr,
|
|
|
|
|
&right->map_start, &right->map_len,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-23 13:14:14 -04:00
|
|
|
if (!empty && push_items > 0) {
|
|
|
|
|
if (path->slots[0] < i)
|
|
|
|
|
break;
|
|
|
|
|
if (path->slots[0] == i) {
|
|
|
|
|
int space = btrfs_leaf_free_space(root, right);
|
|
|
|
|
if (space + push_space * 2 > free_space)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-26 15:51:26 -05:00
|
|
|
if (path->slots[0] == i)
|
2008-12-17 10:21:48 -05:00
|
|
|
push_space += data_size;
|
2007-10-15 16:15:53 -04:00
|
|
|
|
|
|
|
|
this_item_size = btrfs_item_size(right, item);
|
|
|
|
|
if (this_item_size + sizeof(*item) + push_space > free_space)
|
2007-01-26 15:51:26 -05:00
|
|
|
break;
|
2007-10-15 16:15:53 -04:00
|
|
|
|
2007-01-26 15:51:26 -05:00
|
|
|
push_items++;
|
2007-10-15 16:15:53 -04:00
|
|
|
push_space += this_item_size + sizeof(*item);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (right->map_token) {
|
|
|
|
|
unmap_extent_buffer(right, right->map_token, KM_USER1);
|
|
|
|
|
right->map_token = NULL;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
2007-10-15 16:15:53 -04:00
|
|
|
|
2007-01-26 15:51:26 -05:00
|
|
|
if (push_items == 0) {
|
2008-06-25 16:01:30 -04:00
|
|
|
ret = 1;
|
|
|
|
|
goto out;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
2007-11-07 13:31:03 -05:00
|
|
|
if (!empty && push_items == btrfs_header_nritems(right))
|
2007-04-18 16:15:28 -04:00
|
|
|
WARN_ON(1);
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2007-01-26 15:51:26 -05:00
|
|
|
/* push data from right to left */
|
2007-10-15 16:14:19 -04:00
|
|
|
copy_extent_buffer(left, right,
|
|
|
|
|
btrfs_item_nr_offset(btrfs_header_nritems(left)),
|
|
|
|
|
btrfs_item_nr_offset(0),
|
|
|
|
|
push_items * sizeof(struct btrfs_item));
|
|
|
|
|
|
2007-03-14 14:14:43 -04:00
|
|
|
push_space = BTRFS_LEAF_DATA_SIZE(root) -
|
2009-01-05 21:25:51 -05:00
|
|
|
btrfs_item_offset_nr(right, push_items - 1);
|
2007-10-15 16:14:19 -04:00
|
|
|
|
|
|
|
|
copy_extent_buffer(left, right, btrfs_leaf_data(left) +
|
2007-03-30 14:27:56 -04:00
|
|
|
leaf_data_end(root, left) - push_space,
|
|
|
|
|
btrfs_leaf_data(right) +
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_item_offset_nr(right, push_items - 1),
|
2007-03-30 14:27:56 -04:00
|
|
|
push_space);
|
2007-10-15 16:14:19 -04:00
|
|
|
old_left_nritems = btrfs_header_nritems(left);
|
2008-12-17 10:21:48 -05:00
|
|
|
BUG_ON(old_left_nritems <= 0);
|
2007-02-02 09:18:22 -05:00
|
|
|
|
2007-10-15 16:15:53 -04:00
|
|
|
old_left_item_size = btrfs_item_offset_nr(left, old_left_nritems - 1);
|
2007-03-12 20:12:07 -04:00
|
|
|
for (i = old_left_nritems; i < old_left_nritems + push_items; i++) {
|
2007-10-15 16:14:19 -04:00
|
|
|
u32 ioff;
|
2007-10-15 16:15:53 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
item = btrfs_item_nr(left, i);
|
2007-10-15 16:15:53 -04:00
|
|
|
if (!left->map_token) {
|
|
|
|
|
map_extent_buffer(left, (unsigned long)item,
|
|
|
|
|
sizeof(struct btrfs_item),
|
|
|
|
|
&left->map_token, &left->kaddr,
|
|
|
|
|
&left->map_start, &left->map_len,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
ioff = btrfs_item_offset(left, item);
|
|
|
|
|
btrfs_set_item_offset(left, item,
|
2007-10-15 16:15:53 -04:00
|
|
|
ioff - (BTRFS_LEAF_DATA_SIZE(root) - old_left_item_size));
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_nritems(left, old_left_nritems + push_items);
|
2007-10-15 16:15:53 -04:00
|
|
|
if (left->map_token) {
|
|
|
|
|
unmap_extent_buffer(left, left->map_token, KM_USER1);
|
|
|
|
|
left->map_token = NULL;
|
|
|
|
|
}
|
2007-01-26 15:51:26 -05:00
|
|
|
|
|
|
|
|
/* fixup right node */
|
2007-11-07 13:31:03 -05:00
|
|
|
if (push_items > right_nritems) {
|
2009-01-05 21:25:51 -05:00
|
|
|
printk(KERN_CRIT "push items %d nr %u\n", push_items,
|
|
|
|
|
right_nritems);
|
2007-11-07 13:31:03 -05:00
|
|
|
WARN_ON(1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (push_items < right_nritems) {
|
|
|
|
|
push_space = btrfs_item_offset_nr(right, push_items - 1) -
|
|
|
|
|
leaf_data_end(root, right);
|
|
|
|
|
memmove_extent_buffer(right, btrfs_leaf_data(right) +
|
|
|
|
|
BTRFS_LEAF_DATA_SIZE(root) - push_space,
|
|
|
|
|
btrfs_leaf_data(right) +
|
|
|
|
|
leaf_data_end(root, right), push_space);
|
|
|
|
|
|
|
|
|
|
memmove_extent_buffer(right, btrfs_item_nr_offset(0),
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_item_nr_offset(push_items),
|
|
|
|
|
(btrfs_header_nritems(right) - push_items) *
|
|
|
|
|
sizeof(struct btrfs_item));
|
2007-11-07 13:31:03 -05:00
|
|
|
}
|
2007-11-26 10:58:13 -05:00
|
|
|
right_nritems -= push_items;
|
|
|
|
|
btrfs_set_header_nritems(right, right_nritems);
|
2007-03-14 14:14:43 -04:00
|
|
|
push_space = BTRFS_LEAF_DATA_SIZE(root);
|
2007-10-15 16:14:19 -04:00
|
|
|
for (i = 0; i < right_nritems; i++) {
|
|
|
|
|
item = btrfs_item_nr(right, i);
|
2007-10-15 16:15:53 -04:00
|
|
|
|
|
|
|
|
if (!right->map_token) {
|
|
|
|
|
map_extent_buffer(right, (unsigned long)item,
|
|
|
|
|
sizeof(struct btrfs_item),
|
|
|
|
|
&right->map_token, &right->kaddr,
|
|
|
|
|
&right->map_start, &right->map_len,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
push_space = push_space - btrfs_item_size(right, item);
|
|
|
|
|
btrfs_set_item_offset(right, item, push_space);
|
|
|
|
|
}
|
|
|
|
|
if (right->map_token) {
|
|
|
|
|
unmap_extent_buffer(right, right->map_token, KM_USER1);
|
|
|
|
|
right->map_token = NULL;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
2007-02-02 09:18:22 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_mark_buffer_dirty(left);
|
2007-11-07 13:31:03 -05:00
|
|
|
if (right_nritems)
|
|
|
|
|
btrfs_mark_buffer_dirty(right);
|
2007-05-11 11:33:21 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_item_key(right, &disk_key, 0);
|
|
|
|
|
wret = fixup_low_keys(trans, root, path, &disk_key, 1);
|
2007-02-28 16:35:06 -05:00
|
|
|
if (wret)
|
|
|
|
|
ret = wret;
|
2007-01-26 15:51:26 -05:00
|
|
|
|
|
|
|
|
/* then fixup the leaf pointer in the path */
|
|
|
|
|
if (path->slots[0] < push_items) {
|
|
|
|
|
path->slots[0] += old_left_nritems;
|
2008-06-25 16:01:30 -04:00
|
|
|
if (btrfs_header_nritems(path->nodes[0]) == 0)
|
|
|
|
|
clean_tree_block(trans, root, path->nodes[0]);
|
|
|
|
|
btrfs_tree_unlock(path->nodes[0]);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(path->nodes[0]);
|
|
|
|
|
path->nodes[0] = left;
|
2007-01-26 15:51:26 -05:00
|
|
|
path->slots[1] -= 1;
|
|
|
|
|
} else {
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_tree_unlock(left);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(left);
|
2007-01-26 15:51:26 -05:00
|
|
|
path->slots[0] -= push_items;
|
|
|
|
|
}
|
2007-02-02 09:18:22 -05:00
|
|
|
BUG_ON(path->slots[0] < 0);
|
2007-02-28 16:35:06 -05:00
|
|
|
return ret;
|
2008-06-25 16:01:30 -04:00
|
|
|
out:
|
|
|
|
|
btrfs_tree_unlock(left);
|
|
|
|
|
free_extent_buffer(left);
|
|
|
|
|
return ret;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
|
2009-03-13 10:04:31 -04:00
|
|
|
/*
|
|
|
|
|
* push some data in the path leaf to the left, trying to free up at
|
|
|
|
|
* least data_size bytes. returns zero if the push worked, nonzero otherwise
|
|
|
|
|
*/
|
|
|
|
|
static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
|
|
|
|
|
*root, struct btrfs_path *path, int data_size,
|
|
|
|
|
int empty)
|
|
|
|
|
{
|
|
|
|
|
struct extent_buffer *right = path->nodes[0];
|
|
|
|
|
struct extent_buffer *left;
|
|
|
|
|
int slot;
|
|
|
|
|
int free_space;
|
|
|
|
|
u32 right_nritems;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
slot = path->slots[1];
|
|
|
|
|
if (slot == 0)
|
|
|
|
|
return 1;
|
|
|
|
|
if (!path->nodes[1])
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
right_nritems = btrfs_header_nritems(right);
|
|
|
|
|
if (right_nritems == 0)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
btrfs_assert_tree_locked(path->nodes[1]);
|
|
|
|
|
|
|
|
|
|
left = read_node_slot(root, path->nodes[1], slot - 1);
|
|
|
|
|
btrfs_tree_lock(left);
|
|
|
|
|
btrfs_set_lock_blocking(left);
|
|
|
|
|
|
|
|
|
|
free_space = btrfs_leaf_free_space(root, left);
|
|
|
|
|
if (free_space < data_size) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* cow and double check */
|
|
|
|
|
ret = btrfs_cow_block(trans, root, left,
|
|
|
|
|
path->nodes[1], slot - 1, &left);
|
|
|
|
|
if (ret) {
|
|
|
|
|
/* we hit -ENOSPC, but it isn't fatal here */
|
|
|
|
|
ret = 1;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
free_space = btrfs_leaf_free_space(root, left);
|
|
|
|
|
if (free_space < data_size) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return __push_leaf_left(trans, root, path, data_size,
|
|
|
|
|
empty, left, free_space, right_nritems);
|
|
|
|
|
out:
|
|
|
|
|
btrfs_tree_unlock(left);
|
|
|
|
|
free_extent_buffer(left);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* split the path's leaf in two, making sure there is at least data_size
|
|
|
|
|
* available for the resulting leaf level of the path.
|
|
|
|
|
*
|
|
|
|
|
* returns 0 if all went well and < 0 on failure.
|
|
|
|
|
*/
|
|
|
|
|
static noinline int copy_for_split(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path,
|
|
|
|
|
struct extent_buffer *l,
|
|
|
|
|
struct extent_buffer *right,
|
|
|
|
|
int slot, int mid, int nritems)
|
|
|
|
|
{
|
|
|
|
|
int data_copy_size;
|
|
|
|
|
int rt_data_off;
|
|
|
|
|
int i;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int wret;
|
|
|
|
|
struct btrfs_disk_key disk_key;
|
|
|
|
|
|
|
|
|
|
nritems = nritems - mid;
|
|
|
|
|
btrfs_set_header_nritems(right, nritems);
|
|
|
|
|
data_copy_size = btrfs_item_end_nr(l, mid) - leaf_data_end(root, l);
|
|
|
|
|
|
|
|
|
|
copy_extent_buffer(right, l, btrfs_item_nr_offset(0),
|
|
|
|
|
btrfs_item_nr_offset(mid),
|
|
|
|
|
nritems * sizeof(struct btrfs_item));
|
|
|
|
|
|
|
|
|
|
copy_extent_buffer(right, l,
|
|
|
|
|
btrfs_leaf_data(right) + BTRFS_LEAF_DATA_SIZE(root) -
|
|
|
|
|
data_copy_size, btrfs_leaf_data(l) +
|
|
|
|
|
leaf_data_end(root, l), data_copy_size);
|
|
|
|
|
|
|
|
|
|
rt_data_off = BTRFS_LEAF_DATA_SIZE(root) -
|
|
|
|
|
btrfs_item_end_nr(l, mid);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nritems; i++) {
|
|
|
|
|
struct btrfs_item *item = btrfs_item_nr(right, i);
|
|
|
|
|
u32 ioff;
|
|
|
|
|
|
|
|
|
|
if (!right->map_token) {
|
|
|
|
|
map_extent_buffer(right, (unsigned long)item,
|
|
|
|
|
sizeof(struct btrfs_item),
|
|
|
|
|
&right->map_token, &right->kaddr,
|
|
|
|
|
&right->map_start, &right->map_len,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ioff = btrfs_item_offset(right, item);
|
|
|
|
|
btrfs_set_item_offset(right, item, ioff + rt_data_off);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (right->map_token) {
|
|
|
|
|
unmap_extent_buffer(right, right->map_token, KM_USER1);
|
|
|
|
|
right->map_token = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
btrfs_set_header_nritems(l, mid);
|
|
|
|
|
ret = 0;
|
|
|
|
|
btrfs_item_key(right, &disk_key, 0);
|
|
|
|
|
wret = insert_ptr(trans, root, path, &disk_key, right->start,
|
|
|
|
|
path->slots[1] + 1, 1);
|
|
|
|
|
if (wret)
|
|
|
|
|
ret = wret;
|
|
|
|
|
|
|
|
|
|
btrfs_mark_buffer_dirty(right);
|
|
|
|
|
btrfs_mark_buffer_dirty(l);
|
|
|
|
|
BUG_ON(path->slots[0] != slot);
|
|
|
|
|
|
|
|
|
|
if (mid <= slot) {
|
|
|
|
|
btrfs_tree_unlock(path->nodes[0]);
|
|
|
|
|
free_extent_buffer(path->nodes[0]);
|
|
|
|
|
path->nodes[0] = right;
|
|
|
|
|
path->slots[0] -= mid;
|
|
|
|
|
path->slots[1] += 1;
|
|
|
|
|
} else {
|
|
|
|
|
btrfs_tree_unlock(right);
|
|
|
|
|
free_extent_buffer(right);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BUG_ON(path->slots[0] < 0);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/*
|
|
|
|
|
* split the path's leaf in two, making sure there is at least data_size
|
|
|
|
|
* available for the resulting leaf level of the path.
|
2007-02-28 16:35:06 -05:00
|
|
|
*
|
|
|
|
|
* returns 0 if all went well and < 0 on failure.
|
2007-02-02 11:05:29 -05:00
|
|
|
*/
|
2008-09-05 16:13:11 -04:00
|
|
|
static noinline int split_leaf(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_key *ins_key,
|
|
|
|
|
struct btrfs_path *path, int data_size,
|
|
|
|
|
int extend)
|
2007-01-26 15:51:26 -05: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 10:45:14 -04:00
|
|
|
struct btrfs_disk_key disk_key;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *l;
|
2007-03-12 12:01:18 -04:00
|
|
|
u32 nritems;
|
2007-02-02 09:18:22 -05:00
|
|
|
int mid;
|
|
|
|
|
int slot;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *right;
|
2007-04-04 14:08:15 -04:00
|
|
|
int ret = 0;
|
2007-02-28 16:35:06 -05:00
|
|
|
int wret;
|
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 10:45:14 -04:00
|
|
|
int split;
|
2007-10-25 15:42:57 -04:00
|
|
|
int num_doubles = 0;
|
2007-02-28 16:35:06 -05:00
|
|
|
|
2009-09-24 09:17:31 -04:00
|
|
|
l = path->nodes[0];
|
|
|
|
|
slot = path->slots[0];
|
|
|
|
|
if (extend && data_size + btrfs_item_size_nr(l, slot) +
|
|
|
|
|
sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(root))
|
|
|
|
|
return -EOVERFLOW;
|
|
|
|
|
|
2007-03-17 14:29:23 -04:00
|
|
|
/* first try to make some room by pushing left and right */
|
2009-05-13 19:12:15 -04:00
|
|
|
if (data_size && ins_key->type != BTRFS_DIR_ITEM_KEY) {
|
2007-11-07 13:31:03 -05:00
|
|
|
wret = push_leaf_right(trans, root, path, data_size, 0);
|
2009-01-05 21:25:51 -05:00
|
|
|
if (wret < 0)
|
2007-03-13 11:17:52 -04:00
|
|
|
return wret;
|
2007-10-19 09:23:27 -04:00
|
|
|
if (wret) {
|
2007-11-07 13:31:03 -05:00
|
|
|
wret = push_leaf_left(trans, root, path, data_size, 0);
|
2007-10-19 09:23:27 -04:00
|
|
|
if (wret < 0)
|
|
|
|
|
return wret;
|
|
|
|
|
}
|
|
|
|
|
l = path->nodes[0];
|
2007-02-28 16:35:06 -05:00
|
|
|
|
2007-10-19 09:23:27 -04:00
|
|
|
/* did the pushes work? */
|
2008-12-17 10:21:48 -05:00
|
|
|
if (btrfs_leaf_free_space(root, l) >= data_size)
|
2007-10-19 09:23:27 -04:00
|
|
|
return 0;
|
2007-10-15 16:18:25 -04:00
|
|
|
}
|
2007-02-28 16:35:06 -05:00
|
|
|
|
2007-02-22 11:39:13 -05:00
|
|
|
if (!path->nodes[1]) {
|
2007-03-16 16:20:31 -04:00
|
|
|
ret = insert_new_root(trans, root, path, 1);
|
2007-02-22 11:39:13 -05:00
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2007-10-25 15:42:57 -04:00
|
|
|
again:
|
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 10:45:14 -04:00
|
|
|
split = 1;
|
2007-10-25 15:42:57 -04:00
|
|
|
l = path->nodes[0];
|
2007-02-02 09:18:22 -05:00
|
|
|
slot = path->slots[0];
|
2007-10-15 16:14:19 -04:00
|
|
|
nritems = btrfs_header_nritems(l);
|
2009-01-05 21:25:51 -05:00
|
|
|
mid = (nritems + 1) / 2;
|
2007-06-22 14:16:25 -04: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 10:45:14 -04:00
|
|
|
if (mid <= slot) {
|
|
|
|
|
if (nritems == 1 ||
|
|
|
|
|
leaf_space_used(l, mid, nritems - mid) + data_size >
|
|
|
|
|
BTRFS_LEAF_DATA_SIZE(root)) {
|
|
|
|
|
if (slot >= nritems) {
|
|
|
|
|
split = 0;
|
|
|
|
|
} else {
|
|
|
|
|
mid = slot;
|
|
|
|
|
if (mid != nritems &&
|
|
|
|
|
leaf_space_used(l, mid, nritems - mid) +
|
|
|
|
|
data_size > BTRFS_LEAF_DATA_SIZE(root)) {
|
|
|
|
|
split = 2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (leaf_space_used(l, 0, mid) + data_size >
|
|
|
|
|
BTRFS_LEAF_DATA_SIZE(root)) {
|
|
|
|
|
if (!extend && data_size && slot == 0) {
|
|
|
|
|
split = 0;
|
|
|
|
|
} else if ((extend || !data_size) && slot == 0) {
|
|
|
|
|
mid = 1;
|
|
|
|
|
} else {
|
|
|
|
|
mid = slot;
|
|
|
|
|
if (mid != nritems &&
|
|
|
|
|
leaf_space_used(l, mid, nritems - mid) +
|
|
|
|
|
data_size > BTRFS_LEAF_DATA_SIZE(root)) {
|
|
|
|
|
split = 2 ;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (split == 0)
|
|
|
|
|
btrfs_cpu_key_to_disk(&disk_key, ins_key);
|
|
|
|
|
else
|
|
|
|
|
btrfs_item_key(l, &disk_key, mid);
|
|
|
|
|
|
|
|
|
|
right = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
|
2008-09-23 13:14:14 -04:00
|
|
|
root->root_key.objectid,
|
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 10:45:14 -04:00
|
|
|
&disk_key, 0, l->start, 0);
|
2008-04-09 16:28:12 -04:00
|
|
|
if (IS_ERR(right)) {
|
|
|
|
|
BUG_ON(1);
|
2007-10-15 16:14:19 -04:00
|
|
|
return PTR_ERR(right);
|
2008-04-09 16:28:12 -04:00
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
|
|
|
|
|
memset_extent_buffer(right, 0, 0, sizeof(struct btrfs_header));
|
2007-10-15 16:15:53 -04:00
|
|
|
btrfs_set_header_bytenr(right, right->start);
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_generation(right, trans->transid);
|
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 10:45:14 -04:00
|
|
|
btrfs_set_header_backref_rev(right, BTRFS_MIXED_BACKREF_REV);
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_owner(right, root->root_key.objectid);
|
|
|
|
|
btrfs_set_header_level(right, 0);
|
|
|
|
|
write_extent_buffer(right, root->fs_info->fsid,
|
|
|
|
|
(unsigned long)btrfs_header_fsid(right),
|
|
|
|
|
BTRFS_FSID_SIZE);
|
2008-04-15 15:41:47 -04:00
|
|
|
|
|
|
|
|
write_extent_buffer(right, root->fs_info->chunk_tree_uuid,
|
|
|
|
|
(unsigned long)btrfs_header_chunk_tree_uuid(right),
|
|
|
|
|
BTRFS_UUID_SIZE);
|
2009-03-13 10:04:31 -04: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 10:45:14 -04:00
|
|
|
if (split == 0) {
|
|
|
|
|
if (mid <= slot) {
|
|
|
|
|
btrfs_set_header_nritems(right, 0);
|
|
|
|
|
wret = insert_ptr(trans, root, path,
|
|
|
|
|
&disk_key, right->start,
|
|
|
|
|
path->slots[1] + 1, 1);
|
|
|
|
|
if (wret)
|
|
|
|
|
ret = wret;
|
2008-06-25 16:01:30 -04: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 10:45:14 -04:00
|
|
|
btrfs_tree_unlock(path->nodes[0]);
|
|
|
|
|
free_extent_buffer(path->nodes[0]);
|
|
|
|
|
path->nodes[0] = right;
|
|
|
|
|
path->slots[0] = 0;
|
|
|
|
|
path->slots[1] += 1;
|
|
|
|
|
} else {
|
|
|
|
|
btrfs_set_header_nritems(right, 0);
|
|
|
|
|
wret = insert_ptr(trans, root, path,
|
|
|
|
|
&disk_key,
|
|
|
|
|
right->start,
|
|
|
|
|
path->slots[1], 1);
|
|
|
|
|
if (wret)
|
|
|
|
|
ret = wret;
|
|
|
|
|
btrfs_tree_unlock(path->nodes[0]);
|
|
|
|
|
free_extent_buffer(path->nodes[0]);
|
|
|
|
|
path->nodes[0] = right;
|
|
|
|
|
path->slots[0] = 0;
|
|
|
|
|
if (path->slots[1] == 0) {
|
|
|
|
|
wret = fixup_low_keys(trans, root,
|
|
|
|
|
path, &disk_key, 1);
|
2007-04-04 14:08:15 -04:00
|
|
|
if (wret)
|
|
|
|
|
ret = wret;
|
2007-10-19 14:01:21 -04:00
|
|
|
}
|
2007-04-04 14:08:15 -04: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 10:45:14 -04:00
|
|
|
btrfs_mark_buffer_dirty(right);
|
|
|
|
|
return ret;
|
2007-04-04 14:08:15 -04:00
|
|
|
}
|
2007-02-02 11:05:29 -05:00
|
|
|
|
2009-03-13 10:04:31 -04:00
|
|
|
ret = copy_for_split(trans, root, path, l, right, slot, mid, nritems);
|
2008-09-23 13:14:14 -04:00
|
|
|
BUG_ON(ret);
|
|
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 10:45:14 -04:00
|
|
|
if (split == 2) {
|
2007-10-25 15:42:57 -04:00
|
|
|
BUG_ON(num_doubles != 0);
|
|
|
|
|
num_doubles++;
|
|
|
|
|
goto again;
|
2007-04-18 16:15:28 -04:00
|
|
|
}
|
2009-03-13 10:04:31 -04:00
|
|
|
|
2007-01-26 15:51:26 -05:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-10 09:10:46 -05:00
|
|
|
/*
|
|
|
|
|
* This function splits a single item into two items,
|
|
|
|
|
* giving 'new_key' to the new item and splitting the
|
|
|
|
|
* old one at split_offset (from the start of the item).
|
|
|
|
|
*
|
|
|
|
|
* The path may be released by this operation. After
|
|
|
|
|
* the split, the path is pointing to the old item. The
|
|
|
|
|
* new item is going to be in the same node as the old one.
|
|
|
|
|
*
|
|
|
|
|
* Note, the item being split must be smaller enough to live alone on
|
|
|
|
|
* a tree block with room for one extra struct btrfs_item
|
|
|
|
|
*
|
|
|
|
|
* This allows us to split the item in place, keeping a lock on the
|
|
|
|
|
* leaf the entire time.
|
|
|
|
|
*/
|
|
|
|
|
int btrfs_split_item(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path,
|
|
|
|
|
struct btrfs_key *new_key,
|
|
|
|
|
unsigned long split_offset)
|
|
|
|
|
{
|
|
|
|
|
u32 item_size;
|
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
|
struct btrfs_key orig_key;
|
|
|
|
|
struct btrfs_item *item;
|
|
|
|
|
struct btrfs_item *new_item;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int slot;
|
|
|
|
|
u32 nritems;
|
|
|
|
|
u32 orig_offset;
|
|
|
|
|
struct btrfs_disk_key disk_key;
|
|
|
|
|
char *buf;
|
|
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
btrfs_item_key_to_cpu(leaf, &orig_key, path->slots[0]);
|
|
|
|
|
if (btrfs_leaf_free_space(root, leaf) >= sizeof(struct btrfs_item))
|
|
|
|
|
goto split;
|
|
|
|
|
|
|
|
|
|
item_size = btrfs_item_size_nr(leaf, path->slots[0]);
|
|
|
|
|
btrfs_release_path(root, path);
|
|
|
|
|
|
|
|
|
|
path->search_for_split = 1;
|
|
|
|
|
path->keep_locks = 1;
|
|
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(trans, root, &orig_key, path, 0, 1);
|
|
|
|
|
path->search_for_split = 0;
|
|
|
|
|
|
|
|
|
|
/* if our item isn't there or got smaller, return now */
|
|
|
|
|
if (ret != 0 || item_size != btrfs_item_size_nr(path->nodes[0],
|
|
|
|
|
path->slots[0])) {
|
|
|
|
|
path->keep_locks = 0;
|
|
|
|
|
return -EAGAIN;
|
|
|
|
|
}
|
|
|
|
|
|
2009-03-13 11:00:37 -04:00
|
|
|
btrfs_set_path_blocking(path);
|
2008-12-17 10:21:48 -05:00
|
|
|
ret = split_leaf(trans, root, &orig_key, path,
|
|
|
|
|
sizeof(struct btrfs_item), 1);
|
2008-12-10 09:10:46 -05:00
|
|
|
path->keep_locks = 0;
|
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
|
2009-03-13 11:00:37 -04:00
|
|
|
btrfs_unlock_up_safe(path, 1);
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
BUG_ON(btrfs_leaf_free_space(root, leaf) < sizeof(struct btrfs_item));
|
|
|
|
|
|
|
|
|
|
split:
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
/*
|
|
|
|
|
* make sure any changes to the path from split_leaf leave it
|
|
|
|
|
* in a blocking state
|
|
|
|
|
*/
|
|
|
|
|
btrfs_set_path_blocking(path);
|
|
|
|
|
|
2008-12-10 09:10:46 -05:00
|
|
|
item = btrfs_item_nr(leaf, path->slots[0]);
|
|
|
|
|
orig_offset = btrfs_item_offset(leaf, item);
|
|
|
|
|
item_size = btrfs_item_size(leaf, item);
|
|
|
|
|
|
|
|
|
|
buf = kmalloc(item_size, GFP_NOFS);
|
|
|
|
|
read_extent_buffer(leaf, buf, btrfs_item_ptr_offset(leaf,
|
|
|
|
|
path->slots[0]), item_size);
|
|
|
|
|
slot = path->slots[0] + 1;
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
|
|
|
|
|
nritems = btrfs_header_nritems(leaf);
|
|
|
|
|
|
|
|
|
|
if (slot != nritems) {
|
|
|
|
|
/* shift the items */
|
|
|
|
|
memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + 1),
|
|
|
|
|
btrfs_item_nr_offset(slot),
|
|
|
|
|
(nritems - slot) * sizeof(struct btrfs_item));
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
btrfs_cpu_key_to_disk(&disk_key, new_key);
|
|
|
|
|
btrfs_set_item_key(leaf, &disk_key, slot);
|
|
|
|
|
|
|
|
|
|
new_item = btrfs_item_nr(leaf, slot);
|
|
|
|
|
|
|
|
|
|
btrfs_set_item_offset(leaf, new_item, orig_offset);
|
|
|
|
|
btrfs_set_item_size(leaf, new_item, item_size - split_offset);
|
|
|
|
|
|
|
|
|
|
btrfs_set_item_offset(leaf, item,
|
|
|
|
|
orig_offset + item_size - split_offset);
|
|
|
|
|
btrfs_set_item_size(leaf, item, split_offset);
|
|
|
|
|
|
|
|
|
|
btrfs_set_header_nritems(leaf, nritems + 1);
|
|
|
|
|
|
|
|
|
|
/* write the data for the start of the original item */
|
|
|
|
|
write_extent_buffer(leaf, buf,
|
|
|
|
|
btrfs_item_ptr_offset(leaf, path->slots[0]),
|
|
|
|
|
split_offset);
|
|
|
|
|
|
|
|
|
|
/* write the data for the new item */
|
|
|
|
|
write_extent_buffer(leaf, buf + split_offset,
|
|
|
|
|
btrfs_item_ptr_offset(leaf, slot),
|
|
|
|
|
item_size - split_offset);
|
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
if (btrfs_leaf_free_space(root, leaf) < 0) {
|
|
|
|
|
btrfs_print_leaf(root, leaf);
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
|
|
|
|
kfree(buf);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
|
|
|
|
* make the item pointed to by the path smaller. new_size indicates
|
|
|
|
|
* how small to make it, and from_end tells us if we just chop bytes
|
|
|
|
|
* off the end of the item or if we shift the item to chop bytes off
|
|
|
|
|
* the front.
|
|
|
|
|
*/
|
2007-04-17 13:26:50 -04:00
|
|
|
int btrfs_truncate_item(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path,
|
2007-11-01 11:28:41 -04:00
|
|
|
u32 new_size, int from_end)
|
2007-04-17 13:26:50 -04:00
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int slot;
|
|
|
|
|
int slot_orig;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *leaf;
|
|
|
|
|
struct btrfs_item *item;
|
2007-04-17 13:26:50 -04:00
|
|
|
u32 nritems;
|
|
|
|
|
unsigned int data_end;
|
|
|
|
|
unsigned int old_data_start;
|
|
|
|
|
unsigned int old_size;
|
|
|
|
|
unsigned int size_diff;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
slot_orig = path->slots[0];
|
2007-10-15 16:14:19 -04:00
|
|
|
leaf = path->nodes[0];
|
2007-11-01 11:28:41 -04:00
|
|
|
slot = path->slots[0];
|
|
|
|
|
|
|
|
|
|
old_size = btrfs_item_size_nr(leaf, slot);
|
|
|
|
|
if (old_size == new_size)
|
|
|
|
|
return 0;
|
2007-04-17 13:26:50 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
nritems = btrfs_header_nritems(leaf);
|
2007-04-17 13:26:50 -04:00
|
|
|
data_end = leaf_data_end(root, leaf);
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
old_data_start = btrfs_item_offset_nr(leaf, slot);
|
2007-11-01 11:28:41 -04:00
|
|
|
|
2007-04-17 13:26:50 -04:00
|
|
|
size_diff = old_size - new_size;
|
|
|
|
|
|
|
|
|
|
BUG_ON(slot < 0);
|
|
|
|
|
BUG_ON(slot >= nritems);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* item0..itemN ... dataN.offset..dataN.size .. data0.size
|
|
|
|
|
*/
|
|
|
|
|
/* first correct the data pointers */
|
|
|
|
|
for (i = slot; i < nritems; i++) {
|
2007-10-15 16:14:19 -04:00
|
|
|
u32 ioff;
|
|
|
|
|
item = btrfs_item_nr(leaf, i);
|
2007-10-15 16:15:53 -04:00
|
|
|
|
|
|
|
|
if (!leaf->map_token) {
|
|
|
|
|
map_extent_buffer(leaf, (unsigned long)item,
|
|
|
|
|
sizeof(struct btrfs_item),
|
|
|
|
|
&leaf->map_token, &leaf->kaddr,
|
|
|
|
|
&leaf->map_start, &leaf->map_len,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
ioff = btrfs_item_offset(leaf, item);
|
|
|
|
|
btrfs_set_item_offset(leaf, item, ioff + size_diff);
|
2007-04-17 13:26:50 -04:00
|
|
|
}
|
2007-10-15 16:15:53 -04:00
|
|
|
|
|
|
|
|
if (leaf->map_token) {
|
|
|
|
|
unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
|
|
|
|
|
leaf->map_token = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-17 13:26:50 -04:00
|
|
|
/* shift the data */
|
2007-11-01 11:28:41 -04:00
|
|
|
if (from_end) {
|
|
|
|
|
memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
|
|
|
|
|
data_end + size_diff, btrfs_leaf_data(leaf) +
|
|
|
|
|
data_end, old_data_start + new_size - data_end);
|
|
|
|
|
} else {
|
|
|
|
|
struct btrfs_disk_key disk_key;
|
|
|
|
|
u64 offset;
|
|
|
|
|
|
|
|
|
|
btrfs_item_key(leaf, &disk_key, slot);
|
|
|
|
|
|
|
|
|
|
if (btrfs_disk_key_type(&disk_key) == BTRFS_EXTENT_DATA_KEY) {
|
|
|
|
|
unsigned long ptr;
|
|
|
|
|
struct btrfs_file_extent_item *fi;
|
|
|
|
|
|
|
|
|
|
fi = btrfs_item_ptr(leaf, slot,
|
|
|
|
|
struct btrfs_file_extent_item);
|
|
|
|
|
fi = (struct btrfs_file_extent_item *)(
|
|
|
|
|
(unsigned long)fi - size_diff);
|
|
|
|
|
|
|
|
|
|
if (btrfs_file_extent_type(leaf, fi) ==
|
|
|
|
|
BTRFS_FILE_EXTENT_INLINE) {
|
|
|
|
|
ptr = btrfs_item_ptr_offset(leaf, slot);
|
|
|
|
|
memmove_extent_buffer(leaf, ptr,
|
2009-01-05 21:25:51 -05:00
|
|
|
(unsigned long)fi,
|
|
|
|
|
offsetof(struct btrfs_file_extent_item,
|
2007-11-01 11:28:41 -04:00
|
|
|
disk_bytenr));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
|
|
|
|
|
data_end + size_diff, btrfs_leaf_data(leaf) +
|
|
|
|
|
data_end, old_data_start - data_end);
|
|
|
|
|
|
|
|
|
|
offset = btrfs_disk_key_offset(&disk_key);
|
|
|
|
|
btrfs_set_disk_key_offset(&disk_key, offset + size_diff);
|
|
|
|
|
btrfs_set_item_key(leaf, &disk_key, slot);
|
|
|
|
|
if (slot == 0)
|
|
|
|
|
fixup_low_keys(trans, root, path, &disk_key, 1);
|
|
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
|
|
|
|
|
item = btrfs_item_nr(leaf, slot);
|
|
|
|
|
btrfs_set_item_size(leaf, item, new_size);
|
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
2007-04-17 13:26:50 -04:00
|
|
|
|
|
|
|
|
ret = 0;
|
2007-10-15 16:14:19 -04:00
|
|
|
if (btrfs_leaf_free_space(root, leaf) < 0) {
|
|
|
|
|
btrfs_print_leaf(root, leaf);
|
2007-04-17 13:26:50 -04:00
|
|
|
BUG();
|
2007-10-15 16:14:19 -04:00
|
|
|
}
|
2007-04-17 13:26:50 -04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-29 15:18:18 -04:00
|
|
|
/*
|
|
|
|
|
* make the item pointed to by the path bigger, data_size is the new size.
|
|
|
|
|
*/
|
2007-10-15 16:14:19 -04:00
|
|
|
int btrfs_extend_item(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root, struct btrfs_path *path,
|
|
|
|
|
u32 data_size)
|
2007-04-16 09:22:45 -04:00
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int slot;
|
|
|
|
|
int slot_orig;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *leaf;
|
|
|
|
|
struct btrfs_item *item;
|
2007-04-16 09:22:45 -04:00
|
|
|
u32 nritems;
|
|
|
|
|
unsigned int data_end;
|
|
|
|
|
unsigned int old_data;
|
|
|
|
|
unsigned int old_size;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
slot_orig = path->slots[0];
|
2007-10-15 16:14:19 -04:00
|
|
|
leaf = path->nodes[0];
|
2007-04-16 09:22:45 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
nritems = btrfs_header_nritems(leaf);
|
2007-04-16 09:22:45 -04:00
|
|
|
data_end = leaf_data_end(root, leaf);
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
if (btrfs_leaf_free_space(root, leaf) < data_size) {
|
|
|
|
|
btrfs_print_leaf(root, leaf);
|
2007-04-16 09:22:45 -04:00
|
|
|
BUG();
|
2007-10-15 16:14:19 -04:00
|
|
|
}
|
2007-04-16 09:22:45 -04:00
|
|
|
slot = path->slots[0];
|
2007-10-15 16:14:19 -04:00
|
|
|
old_data = btrfs_item_end_nr(leaf, slot);
|
2007-04-16 09:22:45 -04:00
|
|
|
|
|
|
|
|
BUG_ON(slot < 0);
|
2007-10-15 16:18:25 -04:00
|
|
|
if (slot >= nritems) {
|
|
|
|
|
btrfs_print_leaf(root, leaf);
|
2009-01-05 21:25:51 -05:00
|
|
|
printk(KERN_CRIT "slot %d too large, nritems %d\n",
|
|
|
|
|
slot, nritems);
|
2007-10-15 16:18:25 -04:00
|
|
|
BUG_ON(1);
|
|
|
|
|
}
|
2007-04-16 09:22:45 -04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* item0..itemN ... dataN.offset..dataN.size .. data0.size
|
|
|
|
|
*/
|
|
|
|
|
/* first correct the data pointers */
|
|
|
|
|
for (i = slot; i < nritems; i++) {
|
2007-10-15 16:14:19 -04:00
|
|
|
u32 ioff;
|
|
|
|
|
item = btrfs_item_nr(leaf, i);
|
2007-10-15 16:15:53 -04:00
|
|
|
|
|
|
|
|
if (!leaf->map_token) {
|
|
|
|
|
map_extent_buffer(leaf, (unsigned long)item,
|
|
|
|
|
sizeof(struct btrfs_item),
|
|
|
|
|
&leaf->map_token, &leaf->kaddr,
|
|
|
|
|
&leaf->map_start, &leaf->map_len,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
ioff = btrfs_item_offset(leaf, item);
|
|
|
|
|
btrfs_set_item_offset(leaf, item, ioff - data_size);
|
2007-04-16 09:22:45 -04:00
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2007-10-15 16:15:53 -04:00
|
|
|
if (leaf->map_token) {
|
|
|
|
|
unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
|
|
|
|
|
leaf->map_token = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-16 09:22:45 -04:00
|
|
|
/* shift the data */
|
2007-10-15 16:14:19 -04:00
|
|
|
memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
|
2007-04-16 09:22:45 -04:00
|
|
|
data_end - data_size, btrfs_leaf_data(leaf) +
|
|
|
|
|
data_end, old_data - data_end);
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2007-04-16 09:22:45 -04:00
|
|
|
data_end = old_data;
|
2007-10-15 16:14:19 -04:00
|
|
|
old_size = btrfs_item_size_nr(leaf, slot);
|
|
|
|
|
item = btrfs_item_nr(leaf, slot);
|
|
|
|
|
btrfs_set_item_size(leaf, item, old_size + data_size);
|
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
2007-04-16 09:22:45 -04:00
|
|
|
|
|
|
|
|
ret = 0;
|
2007-10-15 16:14:19 -04:00
|
|
|
if (btrfs_leaf_free_space(root, leaf) < 0) {
|
|
|
|
|
btrfs_print_leaf(root, leaf);
|
2007-04-16 09:22:45 -04:00
|
|
|
BUG();
|
2007-10-15 16:14:19 -04:00
|
|
|
}
|
2007-04-16 09:22:45 -04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-12 14:19:50 -05:00
|
|
|
/*
|
|
|
|
|
* Given a key and some data, insert items into the tree.
|
|
|
|
|
* This does all the path init required, making room in the tree if needed.
|
|
|
|
|
* Returns the number of keys that were inserted.
|
|
|
|
|
*/
|
|
|
|
|
int btrfs_insert_some_items(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path,
|
|
|
|
|
struct btrfs_key *cpu_key, u32 *data_size,
|
|
|
|
|
int nr)
|
|
|
|
|
{
|
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
|
struct btrfs_item *item;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int slot;
|
|
|
|
|
int i;
|
|
|
|
|
u32 nritems;
|
|
|
|
|
u32 total_data = 0;
|
|
|
|
|
u32 total_size = 0;
|
|
|
|
|
unsigned int data_end;
|
|
|
|
|
struct btrfs_disk_key disk_key;
|
|
|
|
|
struct btrfs_key found_key;
|
|
|
|
|
|
2008-12-17 10:21:48 -05:00
|
|
|
for (i = 0; i < nr; i++) {
|
|
|
|
|
if (total_size + data_size[i] + sizeof(struct btrfs_item) >
|
|
|
|
|
BTRFS_LEAF_DATA_SIZE(root)) {
|
|
|
|
|
break;
|
|
|
|
|
nr = i;
|
|
|
|
|
}
|
2008-11-12 14:19:50 -05:00
|
|
|
total_data += data_size[i];
|
2008-12-17 10:21:48 -05:00
|
|
|
total_size += data_size[i] + sizeof(struct btrfs_item);
|
|
|
|
|
}
|
|
|
|
|
BUG_ON(nr == 0);
|
2008-11-12 14:19:50 -05:00
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(trans, root, cpu_key, path, total_size, 1);
|
|
|
|
|
if (ret == 0)
|
|
|
|
|
return -EEXIST;
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
|
|
|
|
|
nritems = btrfs_header_nritems(leaf);
|
|
|
|
|
data_end = leaf_data_end(root, leaf);
|
|
|
|
|
|
|
|
|
|
if (btrfs_leaf_free_space(root, leaf) < total_size) {
|
|
|
|
|
for (i = nr; i >= 0; i--) {
|
|
|
|
|
total_data -= data_size[i];
|
|
|
|
|
total_size -= data_size[i] + sizeof(struct btrfs_item);
|
|
|
|
|
if (total_size < btrfs_leaf_free_space(root, leaf))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
nr = i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
slot = path->slots[0];
|
|
|
|
|
BUG_ON(slot < 0);
|
|
|
|
|
|
|
|
|
|
if (slot != nritems) {
|
|
|
|
|
unsigned int old_data = btrfs_item_end_nr(leaf, slot);
|
|
|
|
|
|
|
|
|
|
item = btrfs_item_nr(leaf, slot);
|
|
|
|
|
btrfs_item_key_to_cpu(leaf, &found_key, slot);
|
|
|
|
|
|
|
|
|
|
/* figure out how many keys we can insert in here */
|
|
|
|
|
total_data = data_size[0];
|
|
|
|
|
for (i = 1; i < nr; 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 10:45:14 -04:00
|
|
|
if (btrfs_comp_cpu_keys(&found_key, cpu_key + i) <= 0)
|
2008-11-12 14:19:50 -05:00
|
|
|
break;
|
|
|
|
|
total_data += data_size[i];
|
|
|
|
|
}
|
|
|
|
|
nr = i;
|
|
|
|
|
|
|
|
|
|
if (old_data < data_end) {
|
|
|
|
|
btrfs_print_leaf(root, leaf);
|
2009-01-05 21:25:51 -05:00
|
|
|
printk(KERN_CRIT "slot %d old_data %d data_end %d\n",
|
2008-11-12 14:19:50 -05:00
|
|
|
slot, old_data, data_end);
|
|
|
|
|
BUG_ON(1);
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
* item0..itemN ... dataN.offset..dataN.size .. data0.size
|
|
|
|
|
*/
|
|
|
|
|
/* first correct the data pointers */
|
|
|
|
|
WARN_ON(leaf->map_token);
|
|
|
|
|
for (i = slot; i < nritems; i++) {
|
|
|
|
|
u32 ioff;
|
|
|
|
|
|
|
|
|
|
item = btrfs_item_nr(leaf, i);
|
|
|
|
|
if (!leaf->map_token) {
|
|
|
|
|
map_extent_buffer(leaf, (unsigned long)item,
|
|
|
|
|
sizeof(struct btrfs_item),
|
|
|
|
|
&leaf->map_token, &leaf->kaddr,
|
|
|
|
|
&leaf->map_start, &leaf->map_len,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ioff = btrfs_item_offset(leaf, item);
|
|
|
|
|
btrfs_set_item_offset(leaf, item, ioff - total_data);
|
|
|
|
|
}
|
|
|
|
|
if (leaf->map_token) {
|
|
|
|
|
unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
|
|
|
|
|
leaf->map_token = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* shift the items */
|
|
|
|
|
memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr),
|
|
|
|
|
btrfs_item_nr_offset(slot),
|
|
|
|
|
(nritems - slot) * sizeof(struct btrfs_item));
|
|
|
|
|
|
|
|
|
|
/* shift the data */
|
|
|
|
|
memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
|
|
|
|
|
data_end - total_data, btrfs_leaf_data(leaf) +
|
|
|
|
|
data_end, old_data - data_end);
|
|
|
|
|
data_end = old_data;
|
|
|
|
|
} else {
|
|
|
|
|
/*
|
|
|
|
|
* this sucks but it has to be done, if we are inserting at
|
|
|
|
|
* the end of the leaf only insert 1 of the items, since we
|
|
|
|
|
* have no way of knowing whats on the next leaf and we'd have
|
|
|
|
|
* to drop our current locks to figure it out
|
|
|
|
|
*/
|
|
|
|
|
nr = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* setup the item for the new data */
|
|
|
|
|
for (i = 0; i < nr; i++) {
|
|
|
|
|
btrfs_cpu_key_to_disk(&disk_key, cpu_key + i);
|
|
|
|
|
btrfs_set_item_key(leaf, &disk_key, slot + i);
|
|
|
|
|
item = btrfs_item_nr(leaf, slot + i);
|
|
|
|
|
btrfs_set_item_offset(leaf, item, data_end - data_size[i]);
|
|
|
|
|
data_end -= data_size[i];
|
|
|
|
|
btrfs_set_item_size(leaf, item, data_size[i]);
|
|
|
|
|
}
|
|
|
|
|
btrfs_set_header_nritems(leaf, nritems + nr);
|
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
if (slot == 0) {
|
|
|
|
|
btrfs_cpu_key_to_disk(&disk_key, cpu_key);
|
|
|
|
|
ret = fixup_low_keys(trans, root, path, &disk_key, 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (btrfs_leaf_free_space(root, leaf) < 0) {
|
|
|
|
|
btrfs_print_leaf(root, leaf);
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
|
|
|
|
out:
|
|
|
|
|
if (!ret)
|
|
|
|
|
ret = nr;
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/*
|
2009-03-13 10:04:31 -04:00
|
|
|
* this is a helper for btrfs_insert_empty_items, the main goal here is
|
|
|
|
|
* to save stack depth by doing the bulk of the work in a function
|
|
|
|
|
* that doesn't call btrfs_search_slot
|
2007-02-02 11:05:29 -05:00
|
|
|
*/
|
2009-03-13 10:04:31 -04:00
|
|
|
static noinline_for_stack int
|
|
|
|
|
setup_items_for_insert(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root, struct btrfs_path *path,
|
|
|
|
|
struct btrfs_key *cpu_key, u32 *data_size,
|
|
|
|
|
u32 total_data, u32 total_size, int nr)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_item *item;
|
2008-01-29 15:15:18 -05:00
|
|
|
int i;
|
2007-03-12 12:01:18 -04:00
|
|
|
u32 nritems;
|
2007-01-26 15:51:26 -05:00
|
|
|
unsigned int data_end;
|
2007-03-12 16:22:34 -04:00
|
|
|
struct btrfs_disk_key disk_key;
|
2009-03-13 10:04:31 -04:00
|
|
|
int ret;
|
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
|
int slot;
|
2007-03-12 16:22:34 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
leaf = path->nodes[0];
|
2009-03-13 10:04:31 -04:00
|
|
|
slot = path->slots[0];
|
2007-02-02 11:05:29 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
nritems = btrfs_header_nritems(leaf);
|
2007-03-14 14:14:43 -04:00
|
|
|
data_end = leaf_data_end(root, leaf);
|
2007-02-02 09:18:22 -05:00
|
|
|
|
2008-09-12 15:32:53 -04:00
|
|
|
if (btrfs_leaf_free_space(root, leaf) < total_size) {
|
2007-10-15 16:18:25 -04:00
|
|
|
btrfs_print_leaf(root, leaf);
|
2009-01-05 21:25:51 -05:00
|
|
|
printk(KERN_CRIT "not enough freespace need %u have %d\n",
|
2008-01-29 15:15:18 -05:00
|
|
|
total_size, btrfs_leaf_free_space(root, leaf));
|
2007-01-26 15:51:26 -05:00
|
|
|
BUG();
|
2007-04-04 14:08:15 -04:00
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2007-01-26 15:51:26 -05:00
|
|
|
if (slot != nritems) {
|
2007-10-15 16:14:19 -04:00
|
|
|
unsigned int old_data = btrfs_item_end_nr(leaf, slot);
|
2007-01-26 15:51:26 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
if (old_data < data_end) {
|
|
|
|
|
btrfs_print_leaf(root, leaf);
|
2009-01-05 21:25:51 -05:00
|
|
|
printk(KERN_CRIT "slot %d old_data %d data_end %d\n",
|
2007-10-15 16:14:19 -04:00
|
|
|
slot, old_data, data_end);
|
|
|
|
|
BUG_ON(1);
|
|
|
|
|
}
|
2007-01-26 15:51:26 -05:00
|
|
|
/*
|
|
|
|
|
* item0..itemN ... dataN.offset..dataN.size .. data0.size
|
|
|
|
|
*/
|
|
|
|
|
/* first correct the data pointers */
|
2007-10-15 16:15:53 -04:00
|
|
|
WARN_ON(leaf->map_token);
|
2007-03-12 20:12:07 -04:00
|
|
|
for (i = slot; i < nritems; i++) {
|
2007-10-15 16:14:19 -04:00
|
|
|
u32 ioff;
|
2007-10-15 16:15:53 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
item = btrfs_item_nr(leaf, i);
|
2007-10-15 16:15:53 -04:00
|
|
|
if (!leaf->map_token) {
|
|
|
|
|
map_extent_buffer(leaf, (unsigned long)item,
|
|
|
|
|
sizeof(struct btrfs_item),
|
|
|
|
|
&leaf->map_token, &leaf->kaddr,
|
|
|
|
|
&leaf->map_start, &leaf->map_len,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
ioff = btrfs_item_offset(leaf, item);
|
2008-01-29 15:15:18 -05:00
|
|
|
btrfs_set_item_offset(leaf, item, ioff - total_data);
|
2007-03-12 20:12:07 -04:00
|
|
|
}
|
2007-10-15 16:15:53 -04:00
|
|
|
if (leaf->map_token) {
|
|
|
|
|
unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
|
|
|
|
|
leaf->map_token = NULL;
|
|
|
|
|
}
|
2007-01-26 15:51:26 -05:00
|
|
|
|
|
|
|
|
/* shift the items */
|
2008-01-29 15:15:18 -05:00
|
|
|
memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr),
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_item_nr_offset(slot),
|
2007-03-30 14:27:56 -04:00
|
|
|
(nritems - slot) * sizeof(struct btrfs_item));
|
2007-01-26 15:51:26 -05:00
|
|
|
|
|
|
|
|
/* shift the data */
|
2007-10-15 16:14:19 -04:00
|
|
|
memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
|
2008-01-29 15:15:18 -05:00
|
|
|
data_end - total_data, btrfs_leaf_data(leaf) +
|
2007-03-30 14:27:56 -04:00
|
|
|
data_end, old_data - data_end);
|
2007-01-26 15:51:26 -05:00
|
|
|
data_end = old_data;
|
|
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2007-03-15 12:56:47 -04:00
|
|
|
/* setup the item for the new data */
|
2008-01-29 15:15:18 -05:00
|
|
|
for (i = 0; i < nr; i++) {
|
|
|
|
|
btrfs_cpu_key_to_disk(&disk_key, cpu_key + i);
|
|
|
|
|
btrfs_set_item_key(leaf, &disk_key, slot + i);
|
|
|
|
|
item = btrfs_item_nr(leaf, slot + i);
|
|
|
|
|
btrfs_set_item_offset(leaf, item, data_end - data_size[i]);
|
|
|
|
|
data_end -= data_size[i];
|
|
|
|
|
btrfs_set_item_size(leaf, item, data_size[i]);
|
|
|
|
|
}
|
2009-03-13 10:04:31 -04:00
|
|
|
|
2008-01-29 15:15:18 -05:00
|
|
|
btrfs_set_header_nritems(leaf, nritems + nr);
|
2007-02-28 16:35:06 -05:00
|
|
|
|
|
|
|
|
ret = 0;
|
2008-01-30 11:43:54 -05:00
|
|
|
if (slot == 0) {
|
2009-03-13 10:04:31 -04:00
|
|
|
struct btrfs_disk_key disk_key;
|
2008-01-30 11:43:54 -05:00
|
|
|
btrfs_cpu_key_to_disk(&disk_key, cpu_key);
|
2007-03-16 16:20:31 -04:00
|
|
|
ret = fixup_low_keys(trans, root, path, &disk_key, 1);
|
2008-01-30 11:43:54 -05:00
|
|
|
}
|
2009-03-13 11:00:37 -04:00
|
|
|
btrfs_unlock_up_safe(path, 1);
|
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
2007-02-28 16:35:06 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
if (btrfs_leaf_free_space(root, leaf) < 0) {
|
|
|
|
|
btrfs_print_leaf(root, leaf);
|
2007-01-26 15:51:26 -05:00
|
|
|
BUG();
|
2007-10-15 16:14:19 -04:00
|
|
|
}
|
2009-03-13 10:04:31 -04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Given a key and some data, insert items into the tree.
|
|
|
|
|
* This does all the path init required, making room in the tree if needed.
|
|
|
|
|
*/
|
|
|
|
|
int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path,
|
|
|
|
|
struct btrfs_key *cpu_key, u32 *data_size,
|
|
|
|
|
int nr)
|
|
|
|
|
{
|
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int slot;
|
|
|
|
|
int i;
|
|
|
|
|
u32 total_size = 0;
|
|
|
|
|
u32 total_data = 0;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nr; i++)
|
|
|
|
|
total_data += data_size[i];
|
|
|
|
|
|
|
|
|
|
total_size = total_data + (nr * sizeof(struct btrfs_item));
|
|
|
|
|
ret = btrfs_search_slot(trans, root, cpu_key, path, total_size, 1);
|
|
|
|
|
if (ret == 0)
|
|
|
|
|
return -EEXIST;
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
slot = path->slots[0];
|
|
|
|
|
BUG_ON(slot < 0);
|
|
|
|
|
|
|
|
|
|
ret = setup_items_for_insert(trans, root, path, cpu_key, data_size,
|
|
|
|
|
total_data, total_size, nr);
|
|
|
|
|
|
2007-03-01 18:59:40 -05:00
|
|
|
out:
|
2007-03-15 12:56:47 -04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Given a key and some data, insert an item into the tree.
|
|
|
|
|
* This does all the path init required, making room in the tree if needed.
|
|
|
|
|
*/
|
2007-03-16 16:20:31 -04:00
|
|
|
int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
|
|
|
|
|
*root, struct btrfs_key *cpu_key, void *data, u32
|
|
|
|
|
data_size)
|
2007-03-15 12:56:47 -04:00
|
|
|
{
|
|
|
|
|
int ret = 0;
|
2007-04-02 10:50:19 -04:00
|
|
|
struct btrfs_path *path;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *leaf;
|
|
|
|
|
unsigned long ptr;
|
2007-03-15 12:56:47 -04:00
|
|
|
|
2007-04-02 10:50:19 -04:00
|
|
|
path = btrfs_alloc_path();
|
|
|
|
|
BUG_ON(!path);
|
|
|
|
|
ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
|
2007-03-15 12:56:47 -04:00
|
|
|
if (!ret) {
|
2007-10-15 16:14:19 -04:00
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
|
|
|
|
|
write_extent_buffer(leaf, data, ptr, data_size);
|
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
2007-03-15 12:56:47 -04:00
|
|
|
}
|
2007-04-02 10:50:19 -04:00
|
|
|
btrfs_free_path(path);
|
2007-02-28 16:35:06 -05:00
|
|
|
return ret;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/*
|
2007-02-24 06:24:44 -05:00
|
|
|
* delete the pointer from a given node.
|
2007-02-02 11:05:29 -05:00
|
|
|
*
|
2008-09-29 15:18:18 -04:00
|
|
|
* the tree should have been previously balanced so the deletion does not
|
|
|
|
|
* empty a node.
|
2007-02-02 11:05:29 -05:00
|
|
|
*/
|
2007-03-16 16:20:31 -04:00
|
|
|
static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path, int level, int slot)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *parent = path->nodes[level];
|
2007-03-12 12:01:18 -04:00
|
|
|
u32 nritems;
|
2007-02-28 16:35:06 -05:00
|
|
|
int ret = 0;
|
2007-03-01 12:04:21 -05:00
|
|
|
int wret;
|
2007-01-26 15:51:26 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
nritems = btrfs_header_nritems(parent);
|
2009-01-05 21:25:51 -05:00
|
|
|
if (slot != nritems - 1) {
|
2007-10-15 16:14:19 -04:00
|
|
|
memmove_extent_buffer(parent,
|
|
|
|
|
btrfs_node_key_ptr_offset(slot),
|
|
|
|
|
btrfs_node_key_ptr_offset(slot + 1),
|
2007-03-30 14:27:56 -04:00
|
|
|
sizeof(struct btrfs_key_ptr) *
|
|
|
|
|
(nritems - slot - 1));
|
2007-03-01 12:04:21 -05:00
|
|
|
}
|
2007-03-12 12:01:18 -04:00
|
|
|
nritems--;
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_nritems(parent, nritems);
|
2007-03-12 12:01:18 -04:00
|
|
|
if (nritems == 0 && parent == root->node) {
|
2007-10-15 16:14:19 -04:00
|
|
|
BUG_ON(btrfs_header_level(root->node) != 1);
|
2007-03-01 12:04:21 -05:00
|
|
|
/* just turn the root into a leaf and break */
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_set_header_level(root->node, 0);
|
2007-03-01 12:04:21 -05:00
|
|
|
} else if (slot == 0) {
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_disk_key disk_key;
|
|
|
|
|
|
|
|
|
|
btrfs_node_key(parent, &disk_key, 0);
|
|
|
|
|
wret = fixup_low_keys(trans, root, path, &disk_key, level + 1);
|
2007-02-28 16:46:22 -05:00
|
|
|
if (wret)
|
|
|
|
|
ret = wret;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
2007-03-30 14:27:56 -04:00
|
|
|
btrfs_mark_buffer_dirty(parent);
|
2007-02-28 16:35:06 -05:00
|
|
|
return ret;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
|
2008-10-01 19:05:46 -04:00
|
|
|
/*
|
|
|
|
|
* a helper function to delete the leaf pointed to by path->slots[1] and
|
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 10:45:14 -04:00
|
|
|
* path->nodes[1].
|
2008-10-01 19:05:46 -04:00
|
|
|
*
|
|
|
|
|
* This deletes the pointer in path->nodes[1] and frees the leaf
|
|
|
|
|
* block extent. zero is returned if it all worked out, < 0 otherwise.
|
|
|
|
|
*
|
|
|
|
|
* The path must have already been setup for deleting the leaf, including
|
|
|
|
|
* all the proper balancing. path->nodes[1] must be locked.
|
|
|
|
|
*/
|
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 10:45:14 -04:00
|
|
|
static noinline int btrfs_del_leaf(struct btrfs_trans_handle *trans,
|
|
|
|
|
struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path,
|
|
|
|
|
struct extent_buffer *leaf)
|
2008-10-01 19:05:46 -04: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 10:45:14 -04:00
|
|
|
WARN_ON(btrfs_header_generation(leaf) != trans->transid);
|
2008-10-01 19:05:46 -04:00
|
|
|
ret = del_ptr(trans, root, path, 1, path->slots[1]);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2009-02-04 09:31:28 -05:00
|
|
|
/*
|
|
|
|
|
* btrfs_free_extent is expensive, we want to make sure we
|
|
|
|
|
* aren't holding any locks when we call it
|
|
|
|
|
*/
|
|
|
|
|
btrfs_unlock_up_safe(path, 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 10:45:14 -04:00
|
|
|
ret = btrfs_free_extent(trans, root, leaf->start, leaf->len,
|
|
|
|
|
0, root->root_key.objectid, 0, 0);
|
2008-10-01 19:05:46 -04:00
|
|
|
return ret;
|
|
|
|
|
}
|
2007-02-02 11:05:29 -05:00
|
|
|
/*
|
|
|
|
|
* delete the item at the leaf level in path. If that empties
|
|
|
|
|
* the leaf, remove it from the tree
|
|
|
|
|
*/
|
2008-01-29 15:11:36 -05:00
|
|
|
int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path, int slot, int nr)
|
2007-01-26 15:51:26 -05:00
|
|
|
{
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *leaf;
|
|
|
|
|
struct btrfs_item *item;
|
2008-01-29 15:11:36 -05:00
|
|
|
int last_off;
|
|
|
|
|
int dsize = 0;
|
2007-02-28 16:35:06 -05:00
|
|
|
int ret = 0;
|
|
|
|
|
int wret;
|
2008-01-29 15:11:36 -05:00
|
|
|
int i;
|
2007-03-12 12:01:18 -04:00
|
|
|
u32 nritems;
|
2007-01-26 15:51:26 -05:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
leaf = path->nodes[0];
|
2008-01-29 15:11:36 -05:00
|
|
|
last_off = btrfs_item_offset_nr(leaf, slot + nr - 1);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nr; i++)
|
|
|
|
|
dsize += btrfs_item_size_nr(leaf, slot + i);
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
nritems = btrfs_header_nritems(leaf);
|
2007-01-26 15:51:26 -05:00
|
|
|
|
2008-01-29 15:11:36 -05:00
|
|
|
if (slot + nr != nritems) {
|
2007-03-14 14:14:43 -04:00
|
|
|
int data_end = leaf_data_end(root, leaf);
|
2007-10-15 16:14:19 -04:00
|
|
|
|
|
|
|
|
memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
|
2007-03-30 14:27:56 -04:00
|
|
|
data_end + dsize,
|
|
|
|
|
btrfs_leaf_data(leaf) + data_end,
|
2008-01-29 15:11:36 -05:00
|
|
|
last_off - data_end);
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2008-01-29 15:11:36 -05:00
|
|
|
for (i = slot + nr; i < nritems; i++) {
|
2007-10-15 16:14:19 -04:00
|
|
|
u32 ioff;
|
2007-10-15 16:15:53 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
item = btrfs_item_nr(leaf, i);
|
2007-10-15 16:15:53 -04:00
|
|
|
if (!leaf->map_token) {
|
|
|
|
|
map_extent_buffer(leaf, (unsigned long)item,
|
|
|
|
|
sizeof(struct btrfs_item),
|
|
|
|
|
&leaf->map_token, &leaf->kaddr,
|
|
|
|
|
&leaf->map_start, &leaf->map_len,
|
|
|
|
|
KM_USER1);
|
|
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
ioff = btrfs_item_offset(leaf, item);
|
|
|
|
|
btrfs_set_item_offset(leaf, item, ioff + dsize);
|
2007-03-12 20:12:07 -04:00
|
|
|
}
|
2007-10-15 16:15:53 -04:00
|
|
|
|
|
|
|
|
if (leaf->map_token) {
|
|
|
|
|
unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
|
|
|
|
|
leaf->map_token = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot),
|
2008-01-29 15:11:36 -05:00
|
|
|
btrfs_item_nr_offset(slot + nr),
|
2007-03-30 14:27:56 -04:00
|
|
|
sizeof(struct btrfs_item) *
|
2008-01-29 15:11:36 -05:00
|
|
|
(nritems - slot - nr));
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
2008-01-29 15:11:36 -05:00
|
|
|
btrfs_set_header_nritems(leaf, nritems - nr);
|
|
|
|
|
nritems -= nr;
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/* delete the leaf if we've emptied it */
|
2007-03-12 12:01:18 -04:00
|
|
|
if (nritems == 0) {
|
2007-10-15 16:14:19 -04:00
|
|
|
if (leaf == root->node) {
|
|
|
|
|
btrfs_set_header_level(leaf, 0);
|
2007-02-23 08:38:36 -05:00
|
|
|
} else {
|
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 10:45:14 -04:00
|
|
|
ret = btrfs_del_leaf(trans, root, path, leaf);
|
2008-10-01 19:05:46 -04:00
|
|
|
BUG_ON(ret);
|
2007-02-23 08:38:36 -05:00
|
|
|
}
|
2007-01-26 15:51:26 -05:00
|
|
|
} else {
|
2007-03-12 12:01:18 -04:00
|
|
|
int used = leaf_space_used(leaf, 0, nritems);
|
2007-02-28 16:35:06 -05:00
|
|
|
if (slot == 0) {
|
2007-10-15 16:14:19 -04:00
|
|
|
struct btrfs_disk_key disk_key;
|
|
|
|
|
|
|
|
|
|
btrfs_item_key(leaf, &disk_key, 0);
|
2007-03-16 16:20:31 -04:00
|
|
|
wret = fixup_low_keys(trans, root, path,
|
2007-10-15 16:14:19 -04:00
|
|
|
&disk_key, 1);
|
2007-02-28 16:35:06 -05:00
|
|
|
if (wret)
|
|
|
|
|
ret = wret;
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-02 11:05:29 -05:00
|
|
|
/* delete the leaf if it is mostly empty */
|
2009-07-24 12:42:46 -04:00
|
|
|
if (used < BTRFS_LEAF_DATA_SIZE(root) / 3) {
|
2007-01-26 15:51:26 -05:00
|
|
|
/* push_leaf_left fixes the path.
|
|
|
|
|
* make sure the path still points to our leaf
|
|
|
|
|
* for possible call to del_ptr below
|
|
|
|
|
*/
|
2007-01-26 16:38:42 -05:00
|
|
|
slot = path->slots[1];
|
2007-10-15 16:14:19 -04:00
|
|
|
extent_buffer_get(leaf);
|
|
|
|
|
|
2009-03-13 11:00:37 -04:00
|
|
|
btrfs_set_path_blocking(path);
|
2008-01-29 15:11:36 -05:00
|
|
|
wret = push_leaf_left(trans, root, path, 1, 1);
|
2007-06-22 14:16:25 -04:00
|
|
|
if (wret < 0 && wret != -ENOSPC)
|
2007-02-28 16:35:06 -05:00
|
|
|
ret = wret;
|
2007-10-15 16:14:19 -04:00
|
|
|
|
|
|
|
|
if (path->nodes[0] == leaf &&
|
|
|
|
|
btrfs_header_nritems(leaf)) {
|
2008-01-29 15:11:36 -05:00
|
|
|
wret = push_leaf_right(trans, root, path, 1, 1);
|
2007-06-22 14:16:25 -04:00
|
|
|
if (wret < 0 && wret != -ENOSPC)
|
2007-02-28 16:35:06 -05:00
|
|
|
ret = wret;
|
|
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
|
|
|
|
|
if (btrfs_header_nritems(leaf) == 0) {
|
2008-10-01 19:05:46 -04:00
|
|
|
path->slots[1] = slot;
|
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 10:45:14 -04:00
|
|
|
ret = btrfs_del_leaf(trans, root, path, leaf);
|
2008-10-01 19:05:46 -04:00
|
|
|
BUG_ON(ret);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(leaf);
|
2007-02-24 06:24:44 -05:00
|
|
|
} else {
|
2008-06-25 16:01:30 -04:00
|
|
|
/* if we're still in the path, make sure
|
|
|
|
|
* we're dirty. Otherwise, one of the
|
|
|
|
|
* push_leaf functions must have already
|
|
|
|
|
* dirtied this buffer
|
|
|
|
|
*/
|
|
|
|
|
if (path->nodes[0] == leaf)
|
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(leaf);
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
2007-03-23 10:01:08 -04:00
|
|
|
} else {
|
2007-10-15 16:14:19 -04:00
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
}
|
2007-02-28 16:35:06 -05:00
|
|
|
return ret;
|
2007-01-26 15:51:26 -05:00
|
|
|
}
|
|
|
|
|
|
2007-12-11 09:25:06 -05:00
|
|
|
/*
|
2008-06-25 16:01:30 -04:00
|
|
|
* search the tree again to find a leaf with lesser keys
|
2007-12-11 09:25:06 -05:00
|
|
|
* returns 0 if it found something or 1 if there are no lesser leaves.
|
|
|
|
|
* returns < 0 on io errors.
|
2008-09-29 15:18:18 -04:00
|
|
|
*
|
|
|
|
|
* This may release the path, and so you may lose any locks held at the
|
|
|
|
|
* time you call it.
|
2007-12-11 09:25:06 -05:00
|
|
|
*/
|
|
|
|
|
int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path)
|
|
|
|
|
{
|
2008-06-25 16:01:30 -04:00
|
|
|
struct btrfs_key key;
|
|
|
|
|
struct btrfs_disk_key found_key;
|
|
|
|
|
int ret;
|
2007-12-11 09:25:06 -05:00
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &key, 0);
|
2007-12-11 09:25:06 -05:00
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
if (key.offset > 0)
|
|
|
|
|
key.offset--;
|
|
|
|
|
else if (key.type > 0)
|
|
|
|
|
key.type--;
|
|
|
|
|
else if (key.objectid > 0)
|
|
|
|
|
key.objectid--;
|
|
|
|
|
else
|
|
|
|
|
return 1;
|
2007-12-11 09:25:06 -05:00
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_release_path(root, path);
|
|
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
btrfs_item_key(path->nodes[0], &found_key, 0);
|
|
|
|
|
ret = comp_keys(&found_key, &key);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return 0;
|
|
|
|
|
return 1;
|
2007-12-11 09:25:06 -05:00
|
|
|
}
|
|
|
|
|
|
2008-06-25 16:01:31 -04:00
|
|
|
/*
|
|
|
|
|
* A helper function to walk down the tree starting at min_key, and looking
|
|
|
|
|
* for nodes or leaves that are either in cache or have a minimum
|
2008-09-29 15:18:18 -04:00
|
|
|
* transaction id. This is used by the btree defrag code, and tree logging
|
2008-06-25 16:01:31 -04:00
|
|
|
*
|
|
|
|
|
* This does not cow, but it does stuff the starting key it finds back
|
|
|
|
|
* into min_key, so you can call btrfs_search_slot with cow=1 on the
|
|
|
|
|
* key and get a writable path.
|
|
|
|
|
*
|
|
|
|
|
* This does lock as it descends, and path->keep_locks should be set
|
|
|
|
|
* to 1 by the caller.
|
|
|
|
|
*
|
|
|
|
|
* This honors path->lowest_level to prevent descent past a given level
|
|
|
|
|
* of the tree.
|
|
|
|
|
*
|
2008-09-29 15:18:18 -04:00
|
|
|
* min_trans indicates the oldest transaction that you are interested
|
|
|
|
|
* in walking through. Any nodes or leaves older than min_trans are
|
|
|
|
|
* skipped over (without reading them).
|
|
|
|
|
*
|
2008-06-25 16:01:31 -04:00
|
|
|
* returns zero if something useful was found, < 0 on error and 1 if there
|
|
|
|
|
* was nothing in the tree that matched the search criteria.
|
|
|
|
|
*/
|
|
|
|
|
int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
|
2008-09-05 16:13:11 -04:00
|
|
|
struct btrfs_key *max_key,
|
2008-06-25 16:01:31 -04:00
|
|
|
struct btrfs_path *path, int cache_only,
|
|
|
|
|
u64 min_trans)
|
|
|
|
|
{
|
|
|
|
|
struct extent_buffer *cur;
|
|
|
|
|
struct btrfs_key found_key;
|
|
|
|
|
int slot;
|
2008-07-24 12:19:49 -04:00
|
|
|
int sret;
|
2008-06-25 16:01:31 -04:00
|
|
|
u32 nritems;
|
|
|
|
|
int level;
|
|
|
|
|
int ret = 1;
|
|
|
|
|
|
2008-12-08 16:43:10 -05:00
|
|
|
WARN_ON(!path->keep_locks);
|
2008-06-25 16:01:31 -04:00
|
|
|
again:
|
|
|
|
|
cur = btrfs_lock_root_node(root);
|
|
|
|
|
level = btrfs_header_level(cur);
|
2008-09-05 16:13:11 -04:00
|
|
|
WARN_ON(path->nodes[level]);
|
2008-06-25 16:01:31 -04:00
|
|
|
path->nodes[level] = cur;
|
|
|
|
|
path->locks[level] = 1;
|
|
|
|
|
|
|
|
|
|
if (btrfs_header_generation(cur) < min_trans) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2009-01-05 21:25:51 -05:00
|
|
|
while (1) {
|
2008-06-25 16:01:31 -04:00
|
|
|
nritems = btrfs_header_nritems(cur);
|
|
|
|
|
level = btrfs_header_level(cur);
|
2008-07-24 12:19:49 -04:00
|
|
|
sret = bin_search(cur, min_key, level, &slot);
|
2008-06-25 16:01:31 -04:00
|
|
|
|
2008-10-01 19:05:46 -04:00
|
|
|
/* at the lowest level, we're done, setup the path and exit */
|
|
|
|
|
if (level == path->lowest_level) {
|
2008-09-05 16:13:11 -04:00
|
|
|
if (slot >= nritems)
|
|
|
|
|
goto find_next_key;
|
2008-06-25 16:01:31 -04:00
|
|
|
ret = 0;
|
|
|
|
|
path->slots[level] = slot;
|
|
|
|
|
btrfs_item_key_to_cpu(cur, &found_key, slot);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2008-07-24 12:19:49 -04:00
|
|
|
if (sret && slot > 0)
|
|
|
|
|
slot--;
|
2008-06-25 16:01:31 -04:00
|
|
|
/*
|
|
|
|
|
* check this node pointer against the cache_only and
|
|
|
|
|
* min_trans parameters. If it isn't in cache or is too
|
|
|
|
|
* old, skip to the next one.
|
|
|
|
|
*/
|
2009-01-05 21:25:51 -05:00
|
|
|
while (slot < nritems) {
|
2008-06-25 16:01:31 -04:00
|
|
|
u64 blockptr;
|
|
|
|
|
u64 gen;
|
|
|
|
|
struct extent_buffer *tmp;
|
2008-09-05 16:13:11 -04:00
|
|
|
struct btrfs_disk_key disk_key;
|
|
|
|
|
|
2008-06-25 16:01:31 -04:00
|
|
|
blockptr = btrfs_node_blockptr(cur, slot);
|
|
|
|
|
gen = btrfs_node_ptr_generation(cur, slot);
|
|
|
|
|
if (gen < min_trans) {
|
|
|
|
|
slot++;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!cache_only)
|
|
|
|
|
break;
|
|
|
|
|
|
2008-09-05 16:13:11 -04:00
|
|
|
if (max_key) {
|
|
|
|
|
btrfs_node_key(cur, &disk_key, slot);
|
|
|
|
|
if (comp_keys(&disk_key, max_key) >= 0) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-25 16:01:31 -04:00
|
|
|
tmp = btrfs_find_tree_block(root, blockptr,
|
|
|
|
|
btrfs_level_size(root, level - 1));
|
|
|
|
|
|
|
|
|
|
if (tmp && btrfs_buffer_uptodate(tmp, gen)) {
|
|
|
|
|
free_extent_buffer(tmp);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (tmp)
|
|
|
|
|
free_extent_buffer(tmp);
|
|
|
|
|
slot++;
|
|
|
|
|
}
|
2008-09-05 16:13:11 -04:00
|
|
|
find_next_key:
|
2008-06-25 16:01:31 -04:00
|
|
|
/*
|
|
|
|
|
* we didn't find a candidate key in this node, walk forward
|
|
|
|
|
* and find another one
|
|
|
|
|
*/
|
|
|
|
|
if (slot >= nritems) {
|
2008-09-05 16:13:11 -04:00
|
|
|
path->slots[level] = slot;
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_path_blocking(path);
|
2008-09-05 16:13:11 -04:00
|
|
|
sret = btrfs_find_next_key(root, path, min_key, level,
|
2008-06-25 16:01:31 -04:00
|
|
|
cache_only, min_trans);
|
2008-09-05 16:13:11 -04:00
|
|
|
if (sret == 0) {
|
2008-06-25 16:01:31 -04:00
|
|
|
btrfs_release_path(root, path);
|
|
|
|
|
goto again;
|
|
|
|
|
} else {
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* save our key for returning back */
|
|
|
|
|
btrfs_node_key_to_cpu(cur, &found_key, slot);
|
|
|
|
|
path->slots[level] = slot;
|
|
|
|
|
if (level == path->lowest_level) {
|
|
|
|
|
ret = 0;
|
|
|
|
|
unlock_up(path, level, 1);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_path_blocking(path);
|
2008-06-25 16:01:31 -04:00
|
|
|
cur = read_node_slot(root, cur, slot);
|
|
|
|
|
|
|
|
|
|
btrfs_tree_lock(cur);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
|
2008-06-25 16:01:31 -04:00
|
|
|
path->locks[level - 1] = 1;
|
|
|
|
|
path->nodes[level - 1] = cur;
|
|
|
|
|
unlock_up(path, level, 1);
|
2009-02-12 14:09:45 -05:00
|
|
|
btrfs_clear_path_blocking(path, NULL);
|
2008-06-25 16:01:31 -04:00
|
|
|
}
|
|
|
|
|
out:
|
|
|
|
|
if (ret == 0)
|
|
|
|
|
memcpy(min_key, &found_key, sizeof(found_key));
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_path_blocking(path);
|
2008-06-25 16:01:31 -04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* this is similar to btrfs_next_leaf, but does not try to preserve
|
|
|
|
|
* and fixup the path. It looks for and returns the next key in the
|
|
|
|
|
* tree based on the current path and the cache_only and min_trans
|
|
|
|
|
* parameters.
|
|
|
|
|
*
|
|
|
|
|
* 0 is returned if another key is found, < 0 if there are any errors
|
|
|
|
|
* and 1 is returned if there are no higher keys in the tree
|
|
|
|
|
*
|
|
|
|
|
* path->keep_locks should be set to 1 on the search made before
|
|
|
|
|
* calling this function.
|
|
|
|
|
*/
|
2008-06-25 16:01:31 -04:00
|
|
|
int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
|
2009-07-22 09:59:00 -04:00
|
|
|
struct btrfs_key *key, int level,
|
2008-06-25 16:01:31 -04:00
|
|
|
int cache_only, u64 min_trans)
|
2008-06-25 16:01:31 -04:00
|
|
|
{
|
|
|
|
|
int slot;
|
|
|
|
|
struct extent_buffer *c;
|
|
|
|
|
|
2008-12-08 16:43:10 -05:00
|
|
|
WARN_ON(!path->keep_locks);
|
2009-01-05 21:25:51 -05:00
|
|
|
while (level < BTRFS_MAX_LEVEL) {
|
2008-06-25 16:01:31 -04:00
|
|
|
if (!path->nodes[level])
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
slot = path->slots[level] + 1;
|
|
|
|
|
c = path->nodes[level];
|
2008-06-25 16:01:31 -04:00
|
|
|
next:
|
2008-06-25 16:01:31 -04:00
|
|
|
if (slot >= btrfs_header_nritems(c)) {
|
2009-07-22 09:59:00 -04:00
|
|
|
int ret;
|
|
|
|
|
int orig_lowest;
|
|
|
|
|
struct btrfs_key cur_key;
|
|
|
|
|
if (level + 1 >= BTRFS_MAX_LEVEL ||
|
|
|
|
|
!path->nodes[level + 1])
|
2008-06-25 16:01:31 -04:00
|
|
|
return 1;
|
2009-07-22 09:59:00 -04:00
|
|
|
|
|
|
|
|
if (path->locks[level + 1]) {
|
|
|
|
|
level++;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
slot = btrfs_header_nritems(c) - 1;
|
|
|
|
|
if (level == 0)
|
|
|
|
|
btrfs_item_key_to_cpu(c, &cur_key, slot);
|
|
|
|
|
else
|
|
|
|
|
btrfs_node_key_to_cpu(c, &cur_key, slot);
|
|
|
|
|
|
|
|
|
|
orig_lowest = path->lowest_level;
|
|
|
|
|
btrfs_release_path(root, path);
|
|
|
|
|
path->lowest_level = level;
|
|
|
|
|
ret = btrfs_search_slot(NULL, root, &cur_key, path,
|
|
|
|
|
0, 0);
|
|
|
|
|
path->lowest_level = orig_lowest;
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
c = path->nodes[level];
|
|
|
|
|
slot = path->slots[level];
|
|
|
|
|
if (ret == 0)
|
|
|
|
|
slot++;
|
|
|
|
|
goto next;
|
2008-06-25 16:01:31 -04:00
|
|
|
}
|
2009-07-22 09:59:00 -04:00
|
|
|
|
2008-06-25 16:01:31 -04:00
|
|
|
if (level == 0)
|
|
|
|
|
btrfs_item_key_to_cpu(c, key, slot);
|
2008-06-25 16:01:31 -04:00
|
|
|
else {
|
|
|
|
|
u64 blockptr = btrfs_node_blockptr(c, slot);
|
|
|
|
|
u64 gen = btrfs_node_ptr_generation(c, slot);
|
|
|
|
|
|
|
|
|
|
if (cache_only) {
|
|
|
|
|
struct extent_buffer *cur;
|
|
|
|
|
cur = btrfs_find_tree_block(root, blockptr,
|
|
|
|
|
btrfs_level_size(root, level - 1));
|
|
|
|
|
if (!cur || !btrfs_buffer_uptodate(cur, gen)) {
|
|
|
|
|
slot++;
|
|
|
|
|
if (cur)
|
|
|
|
|
free_extent_buffer(cur);
|
|
|
|
|
goto next;
|
|
|
|
|
}
|
|
|
|
|
free_extent_buffer(cur);
|
|
|
|
|
}
|
|
|
|
|
if (gen < min_trans) {
|
|
|
|
|
slot++;
|
|
|
|
|
goto next;
|
|
|
|
|
}
|
2008-06-25 16:01:31 -04:00
|
|
|
btrfs_node_key_to_cpu(c, key, slot);
|
2008-06-25 16:01:31 -04:00
|
|
|
}
|
2008-06-25 16:01:31 -04:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-24 13:39:08 -05:00
|
|
|
/*
|
2008-06-25 16:01:30 -04:00
|
|
|
* search the tree again to find a leaf with greater keys
|
2007-02-28 16:46:22 -05:00
|
|
|
* returns 0 if it found something or 1 if there are no greater leaves.
|
|
|
|
|
* returns < 0 on io errors.
|
2007-02-24 13:39:08 -05:00
|
|
|
*/
|
2007-03-13 10:46:10 -04:00
|
|
|
int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
|
2007-02-20 16:40:44 -05:00
|
|
|
{
|
|
|
|
|
int slot;
|
2009-04-03 10:14:18 -04:00
|
|
|
int level;
|
2007-10-15 16:14:19 -04:00
|
|
|
struct extent_buffer *c;
|
2009-04-03 10:14:18 -04:00
|
|
|
struct extent_buffer *next;
|
2008-06-25 16:01:30 -04:00
|
|
|
struct btrfs_key key;
|
|
|
|
|
u32 nritems;
|
|
|
|
|
int ret;
|
2009-04-03 10:14:18 -04:00
|
|
|
int old_spinning = path->leave_spinning;
|
|
|
|
|
int force_blocking = 0;
|
2008-06-25 16:01:30 -04:00
|
|
|
|
|
|
|
|
nritems = btrfs_header_nritems(path->nodes[0]);
|
2009-01-05 21:25:51 -05:00
|
|
|
if (nritems == 0)
|
2008-06-25 16:01:30 -04:00
|
|
|
return 1;
|
|
|
|
|
|
2009-04-03 10:14:18 -04:00
|
|
|
/*
|
|
|
|
|
* we take the blocks in an order that upsets lockdep. Using
|
|
|
|
|
* blocking mode is the only way around it.
|
|
|
|
|
*/
|
|
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
|
|
|
force_blocking = 1;
|
|
|
|
|
#endif
|
2008-06-25 16:01:30 -04:00
|
|
|
|
2009-04-03 10:14:18 -04:00
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &key, nritems - 1);
|
|
|
|
|
again:
|
|
|
|
|
level = 1;
|
|
|
|
|
next = NULL;
|
2008-06-25 16:01:30 -04:00
|
|
|
btrfs_release_path(root, path);
|
2009-04-03 10:14:18 -04:00
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
path->keep_locks = 1;
|
2009-04-03 10:14:18 -04:00
|
|
|
|
|
|
|
|
if (!force_blocking)
|
|
|
|
|
path->leave_spinning = 1;
|
|
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
|
|
|
path->keep_locks = 0;
|
|
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
nritems = btrfs_header_nritems(path->nodes[0]);
|
2008-06-25 16:01:30 -04:00
|
|
|
/*
|
|
|
|
|
* by releasing the path above we dropped all our locks. A balance
|
|
|
|
|
* could have added more items next to the key that used to be
|
|
|
|
|
* at the very end of the block. So, check again here and
|
|
|
|
|
* advance the path if there are now more items available.
|
|
|
|
|
*/
|
2008-06-25 16:01:30 -04:00
|
|
|
if (nritems > 0 && path->slots[0] < nritems - 1) {
|
2009-07-22 09:59:00 -04:00
|
|
|
if (ret == 0)
|
|
|
|
|
path->slots[0]++;
|
2009-04-03 10:14:18 -04:00
|
|
|
ret = 0;
|
2008-06-25 16:01:30 -04:00
|
|
|
goto done;
|
|
|
|
|
}
|
2007-02-20 16:40:44 -05:00
|
|
|
|
2009-01-05 21:25:51 -05:00
|
|
|
while (level < BTRFS_MAX_LEVEL) {
|
2009-04-03 10:14:18 -04:00
|
|
|
if (!path->nodes[level]) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2007-02-20 16:40:44 -05:00
|
|
|
slot = path->slots[level] + 1;
|
|
|
|
|
c = path->nodes[level];
|
2007-10-15 16:14:19 -04:00
|
|
|
if (slot >= btrfs_header_nritems(c)) {
|
2007-02-20 16:40:44 -05:00
|
|
|
level++;
|
2009-04-03 10:14:18 -04:00
|
|
|
if (level == BTRFS_MAX_LEVEL) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
2007-02-20 16:40:44 -05:00
|
|
|
continue;
|
|
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
if (next) {
|
|
|
|
|
btrfs_tree_unlock(next);
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(next);
|
2008-06-25 16:01:30 -04:00
|
|
|
}
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2009-04-03 10:14:18 -04:00
|
|
|
next = c;
|
|
|
|
|
ret = read_block_for_search(NULL, root, path, &next, level,
|
|
|
|
|
slot, &key);
|
|
|
|
|
if (ret == -EAGAIN)
|
|
|
|
|
goto again;
|
2007-10-15 16:14:19 -04:00
|
|
|
|
2009-05-14 13:24:30 -04:00
|
|
|
if (ret < 0) {
|
|
|
|
|
btrfs_release_path(root, path);
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
if (!path->skip_locking) {
|
2009-04-03 10:14:18 -04:00
|
|
|
ret = btrfs_try_spin_lock(next);
|
|
|
|
|
if (!ret) {
|
|
|
|
|
btrfs_set_path_blocking(path);
|
|
|
|
|
btrfs_tree_lock(next);
|
|
|
|
|
if (!force_blocking)
|
|
|
|
|
btrfs_clear_path_blocking(path, next);
|
|
|
|
|
}
|
|
|
|
|
if (force_blocking)
|
|
|
|
|
btrfs_set_lock_blocking(next);
|
2008-06-25 16:01:30 -04:00
|
|
|
}
|
2007-02-20 16:40:44 -05:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
path->slots[level] = slot;
|
2009-01-05 21:25:51 -05:00
|
|
|
while (1) {
|
2007-02-20 16:40:44 -05:00
|
|
|
level--;
|
|
|
|
|
c = path->nodes[level];
|
2008-06-25 16:01:30 -04:00
|
|
|
if (path->locks[level])
|
|
|
|
|
btrfs_tree_unlock(c);
|
2009-04-03 10:14:18 -04:00
|
|
|
|
2007-10-15 16:14:19 -04:00
|
|
|
free_extent_buffer(c);
|
2007-02-20 16:40:44 -05:00
|
|
|
path->nodes[level] = next;
|
|
|
|
|
path->slots[level] = 0;
|
2008-06-25 16:01:31 -04:00
|
|
|
if (!path->skip_locking)
|
|
|
|
|
path->locks[level] = 1;
|
2009-04-03 10:14:18 -04:00
|
|
|
|
2007-02-20 16:40:44 -05:00
|
|
|
if (!level)
|
|
|
|
|
break;
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
|
2009-04-03 10:14:18 -04:00
|
|
|
ret = read_block_for_search(NULL, root, path, &next, level,
|
|
|
|
|
0, &key);
|
|
|
|
|
if (ret == -EAGAIN)
|
|
|
|
|
goto again;
|
|
|
|
|
|
2009-05-14 13:24:30 -04:00
|
|
|
if (ret < 0) {
|
|
|
|
|
btrfs_release_path(root, path);
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-25 16:01:30 -04:00
|
|
|
if (!path->skip_locking) {
|
2009-03-09 11:45:38 -04:00
|
|
|
btrfs_assert_tree_locked(path->nodes[level]);
|
2009-04-03 10:14:18 -04:00
|
|
|
ret = btrfs_try_spin_lock(next);
|
|
|
|
|
if (!ret) {
|
|
|
|
|
btrfs_set_path_blocking(path);
|
|
|
|
|
btrfs_tree_lock(next);
|
|
|
|
|
if (!force_blocking)
|
|
|
|
|
btrfs_clear_path_blocking(path, next);
|
|
|
|
|
}
|
|
|
|
|
if (force_blocking)
|
|
|
|
|
btrfs_set_lock_blocking(next);
|
2008-06-25 16:01:30 -04:00
|
|
|
}
|
2007-02-20 16:40:44 -05:00
|
|
|
}
|
2009-04-03 10:14:18 -04:00
|
|
|
ret = 0;
|
2008-06-25 16:01:30 -04:00
|
|
|
done:
|
|
|
|
|
unlock_up(path, 0, 1);
|
2009-04-03 10:14:18 -04:00
|
|
|
path->leave_spinning = old_spinning;
|
|
|
|
|
if (!old_spinning)
|
|
|
|
|
btrfs_set_path_blocking(path);
|
|
|
|
|
|
|
|
|
|
return ret;
|
2007-02-20 16:40:44 -05:00
|
|
|
}
|
2008-03-24 15:01:56 -04:00
|
|
|
|
2008-06-25 16:01:31 -04:00
|
|
|
/*
|
|
|
|
|
* this uses btrfs_prev_leaf to walk backwards in the tree, and keeps
|
|
|
|
|
* searching until it gets past min_objectid or finds an item of 'type'
|
|
|
|
|
*
|
|
|
|
|
* returns 0 if something is found, 1 if nothing was found and < 0 on error
|
|
|
|
|
*/
|
2008-03-24 15:01:56 -04:00
|
|
|
int btrfs_previous_item(struct btrfs_root *root,
|
|
|
|
|
struct btrfs_path *path, u64 min_objectid,
|
|
|
|
|
int type)
|
|
|
|
|
{
|
|
|
|
|
struct btrfs_key found_key;
|
|
|
|
|
struct extent_buffer *leaf;
|
2008-09-05 16:13:11 -04:00
|
|
|
u32 nritems;
|
2008-03-24 15:01:56 -04:00
|
|
|
int ret;
|
|
|
|
|
|
2009-01-05 21:25:51 -05:00
|
|
|
while (1) {
|
2008-03-24 15:01:56 -04:00
|
|
|
if (path->slots[0] == 0) {
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 09:25:08 -05:00
|
|
|
btrfs_set_path_blocking(path);
|
2008-03-24 15:01:56 -04:00
|
|
|
ret = btrfs_prev_leaf(root, path);
|
|
|
|
|
if (ret != 0)
|
|
|
|
|
return ret;
|
|
|
|
|
} else {
|
|
|
|
|
path->slots[0]--;
|
|
|
|
|
}
|
|
|
|
|
leaf = path->nodes[0];
|
2008-09-05 16:13:11 -04:00
|
|
|
nritems = btrfs_header_nritems(leaf);
|
|
|
|
|
if (nritems == 0)
|
|
|
|
|
return 1;
|
|
|
|
|
if (path->slots[0] == nritems)
|
|
|
|
|
path->slots[0]--;
|
|
|
|
|
|
2008-03-24 15:01:56 -04:00
|
|
|
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
|
2008-09-05 16:13:11 -04:00
|
|
|
if (found_key.objectid < min_objectid)
|
|
|
|
|
break;
|
2009-07-24 11:06:53 -04:00
|
|
|
if (found_key.type == type)
|
|
|
|
|
return 0;
|
2008-09-05 16:13:11 -04:00
|
|
|
if (found_key.objectid == min_objectid &&
|
|
|
|
|
found_key.type < type)
|
|
|
|
|
break;
|
2008-03-24 15:01:56 -04:00
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
