2007-06-12 07:07:21 -06:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2007 Oracle. All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
* License v2 as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public
|
|
|
|
* License along with this program; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 021110-1307, USA.
|
|
|
|
*/
|
|
|
|
|
2007-03-13 14:47:54 -06:00
|
|
|
#include "ctree.h"
|
2007-06-22 12:16:25 -06:00
|
|
|
#include "transaction.h"
|
2007-03-13 14:47:54 -06:00
|
|
|
#include "disk-io.h"
|
|
|
|
#include "print-tree.h"
|
|
|
|
|
2008-05-08 11:26:18 -06:00
|
|
|
/*
|
|
|
|
* returns 0 on finding something, 1 if no more roots are there
|
|
|
|
* and < 0 on error
|
|
|
|
*/
|
|
|
|
int btrfs_search_root(struct btrfs_root *root, u64 search_start,
|
|
|
|
u64 *found_objectid)
|
|
|
|
{
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_key search_key;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
root = root->fs_info->tree_root;
|
|
|
|
search_key.objectid = search_start;
|
|
|
|
search_key.type = (u8)-1;
|
|
|
|
search_key.offset = (u64)-1;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
BUG_ON(!path);
|
|
|
|
again:
|
|
|
|
ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
if (ret == 0) {
|
|
|
|
ret = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
|
|
|
|
ret = btrfs_next_leaf(root, path);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &search_key, path->slots[0]);
|
|
|
|
if (search_key.type != BTRFS_ROOT_ITEM_KEY) {
|
|
|
|
search_key.offset++;
|
|
|
|
btrfs_release_path(root, path);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
*found_objectid = search_key.objectid;
|
|
|
|
|
|
|
|
out:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-03-13 14:47:54 -06:00
|
|
|
int btrfs_find_last_root(struct btrfs_root *root, u64 objectid,
|
|
|
|
struct btrfs_root_item *item, struct btrfs_key *key)
|
|
|
|
{
|
2007-04-02 09:20:42 -06:00
|
|
|
struct btrfs_path *path;
|
2007-03-13 14:47:54 -06:00
|
|
|
struct btrfs_key search_key;
|
2007-10-15 14:14:19 -06:00
|
|
|
struct btrfs_key found_key;
|
|
|
|
struct extent_buffer *l;
|
2007-03-13 14:47:54 -06:00
|
|
|
int ret;
|
|
|
|
int slot;
|
|
|
|
|
|
|
|
search_key.objectid = objectid;
|
2007-10-15 14:14:19 -06:00
|
|
|
search_key.type = (u8)-1;
|
2007-06-22 12:16:25 -06:00
|
|
|
search_key.offset = (u64)-1;
|
2007-03-13 14:47:54 -06:00
|
|
|
|
2007-04-02 09:20:42 -06:00
|
|
|
path = btrfs_alloc_path();
|
|
|
|
BUG_ON(!path);
|
|
|
|
ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
|
2007-03-13 14:47:54 -06:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2007-10-15 14:14:19 -06:00
|
|
|
|
2007-03-13 14:47:54 -06:00
|
|
|
BUG_ON(ret == 0);
|
2007-10-15 14:14:19 -06:00
|
|
|
l = path->nodes[0];
|
2007-04-02 09:20:42 -06:00
|
|
|
BUG_ON(path->slots[0] == 0);
|
|
|
|
slot = path->slots[0] - 1;
|
2007-10-15 14:14:19 -06:00
|
|
|
btrfs_item_key_to_cpu(l, &found_key, slot);
|
|
|
|
if (found_key.objectid != objectid) {
|
2007-03-13 14:47:54 -06:00
|
|
|
ret = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
2007-10-15 14:14:19 -06:00
|
|
|
read_extent_buffer(l, item, btrfs_item_ptr_offset(l, slot),
|
|
|
|
sizeof(*item));
|
|
|
|
memcpy(key, &found_key, sizeof(found_key));
|
2007-03-13 14:47:54 -06:00
|
|
|
ret = 0;
|
|
|
|
out:
|
2007-04-02 09:20:42 -06:00
|
|
|
btrfs_free_path(path);
|
2007-03-13 14:47:54 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-03-16 14:20:31 -06:00
|
|
|
int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
|
|
|
|
*root, struct btrfs_key *key, struct btrfs_root_item
|
|
|
|
*item)
|
2007-03-13 14:47:54 -06:00
|
|
|
{
|
2007-04-02 09:20:42 -06:00
|
|
|
struct btrfs_path *path;
|
2007-10-15 14:14:19 -06:00
|
|
|
struct extent_buffer *l;
|
2007-03-13 14:47:54 -06:00
|
|
|
int ret;
|
|
|
|
int slot;
|
2007-10-15 14:14:19 -06:00
|
|
|
unsigned long ptr;
|
2007-03-13 14:47:54 -06:00
|
|
|
|
2007-04-02 09:20:42 -06:00
|
|
|
path = btrfs_alloc_path();
|
|
|
|
BUG_ON(!path);
|
|
|
|
ret = btrfs_search_slot(trans, root, key, path, 0, 1);
|
2007-03-13 14:47:54 -06:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2008-01-03 12:51:00 -07:00
|
|
|
|
|
|
|
if (ret != 0) {
|
|
|
|
btrfs_print_leaf(root, path->nodes[0]);
|
|
|
|
printk("unable to update root key %Lu %u %Lu\n",
|
|
|
|
key->objectid, key->type, key->offset);
|
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
|
2007-10-15 14:14:19 -06:00
|
|
|
l = path->nodes[0];
|
2007-04-02 09:20:42 -06:00
|
|
|
slot = path->slots[0];
|
2007-10-15 14:14:19 -06:00
|
|
|
ptr = btrfs_item_ptr_offset(l, slot);
|
|
|
|
write_extent_buffer(l, item, ptr, sizeof(*item));
|
2007-04-02 09:20:42 -06:00
|
|
|
btrfs_mark_buffer_dirty(path->nodes[0]);
|
2007-03-13 14:47:54 -06:00
|
|
|
out:
|
2007-04-02 09:20:42 -06:00
|
|
|
btrfs_release_path(root, path);
|
|
|
|
btrfs_free_path(path);
|
2007-03-13 14:47:54 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-03-16 14:20:31 -06:00
|
|
|
int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
|
|
|
|
*root, struct btrfs_key *key, struct btrfs_root_item
|
|
|
|
*item)
|
2007-03-13 14:47:54 -06:00
|
|
|
{
|
|
|
|
int ret;
|
2007-03-16 14:20:31 -06:00
|
|
|
ret = btrfs_insert_item(trans, root, key, item, sizeof(*item));
|
2007-03-13 14:47:54 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-09-11 09:15:39 -06:00
|
|
|
int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid,
|
|
|
|
struct btrfs_root *latest)
|
2007-06-22 12:16:25 -06:00
|
|
|
{
|
|
|
|
struct btrfs_root *dead_root;
|
|
|
|
struct btrfs_item *item;
|
|
|
|
struct btrfs_root_item *ri;
|
|
|
|
struct btrfs_key key;
|
2008-06-26 08:34:20 -06:00
|
|
|
struct btrfs_key found_key;
|
2007-06-22 12:16:25 -06:00
|
|
|
struct btrfs_path *path;
|
|
|
|
int ret;
|
|
|
|
u32 nritems;
|
2007-10-15 14:14:19 -06:00
|
|
|
struct extent_buffer *leaf;
|
2007-06-22 12:16:25 -06:00
|
|
|
int slot;
|
|
|
|
|
2007-09-11 09:15:39 -06:00
|
|
|
key.objectid = objectid;
|
2007-06-22 12:16:25 -06:00
|
|
|
btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
|
|
|
|
key.offset = 0;
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
2008-06-26 08:34:20 -06:00
|
|
|
|
|
|
|
again:
|
2007-06-22 12:16:25 -06:00
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err;
|
|
|
|
while(1) {
|
2007-10-15 14:14:19 -06:00
|
|
|
leaf = path->nodes[0];
|
|
|
|
nritems = btrfs_header_nritems(leaf);
|
2007-06-22 12:16:25 -06:00
|
|
|
slot = path->slots[0];
|
|
|
|
if (slot >= nritems) {
|
|
|
|
ret = btrfs_next_leaf(root, path);
|
|
|
|
if (ret)
|
|
|
|
break;
|
2007-10-15 14:14:19 -06:00
|
|
|
leaf = path->nodes[0];
|
|
|
|
nritems = btrfs_header_nritems(leaf);
|
2007-06-22 12:16:25 -06:00
|
|
|
slot = path->slots[0];
|
|
|
|
}
|
2007-10-15 14:14:19 -06:00
|
|
|
item = btrfs_item_nr(leaf, slot);
|
|
|
|
btrfs_item_key_to_cpu(leaf, &key, slot);
|
2007-06-22 12:16:25 -06:00
|
|
|
if (btrfs_key_type(&key) != BTRFS_ROOT_ITEM_KEY)
|
|
|
|
goto next;
|
2007-09-11 09:15:39 -06:00
|
|
|
|
|
|
|
if (key.objectid < objectid)
|
|
|
|
goto next;
|
|
|
|
|
|
|
|
if (key.objectid > objectid)
|
|
|
|
break;
|
|
|
|
|
2007-06-22 12:16:25 -06:00
|
|
|
ri = btrfs_item_ptr(leaf, slot, struct btrfs_root_item);
|
2007-10-15 14:14:19 -06:00
|
|
|
if (btrfs_disk_root_refs(leaf, ri) != 0)
|
2007-06-22 12:16:25 -06:00
|
|
|
goto next;
|
2007-09-11 09:15:39 -06:00
|
|
|
|
2008-06-26 08:34:20 -06:00
|
|
|
memcpy(&found_key, &key, sizeof(key));
|
|
|
|
key.offset++;
|
|
|
|
btrfs_release_path(root, path);
|
2008-09-05 14:13:11 -06:00
|
|
|
dead_root =
|
|
|
|
btrfs_read_fs_root_no_radix(root->fs_info->tree_root,
|
|
|
|
&found_key);
|
2007-07-11 08:03:27 -06:00
|
|
|
if (IS_ERR(dead_root)) {
|
|
|
|
ret = PTR_ERR(dead_root);
|
2007-06-22 12:16:25 -06:00
|
|
|
goto err;
|
|
|
|
}
|
2007-09-11 09:15:39 -06:00
|
|
|
|
Btrfs: update space balancing code
This patch updates the space balancing code to utilize the new
backref format. Before, btrfs-vol -b would break any COW links
on data blocks or metadata. This was slow and caused the amount
of space used to explode if a large number of snapshots were present.
The new code can keeps the sharing of all data extents and
most of the tree blocks.
To maintain the sharing of data extents, the space balance code uses
a seperate inode hold data extent pointers, then updates the references
to point to the new location.
To maintain the sharing of tree blocks, the space balance code uses
reloc trees to relocate tree blocks in reference counted roots.
There is one reloc tree for each subvol, and all reloc trees share
same root key objectid. Reloc trees are snapshots of the latest
committed roots of subvols (root->commit_root).
To relocate a tree block referenced by a subvol, there are two steps.
COW the block through subvol's reloc tree, then update block pointer in
the subvol to point to the new block. Since all reloc trees share
same root key objectid, doing special handing for tree blocks
owned by them is easy. Once a tree block has been COWed in one
reloc tree, we can use the resulting new block directly when the
same block is required to COW again through other reloc trees.
In this way, relocated tree blocks are shared between reloc trees,
so they are also shared between subvols.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-09-26 08:09:34 -06:00
|
|
|
if (objectid == BTRFS_TREE_RELOC_OBJECTID)
|
|
|
|
ret = btrfs_add_dead_reloc_root(dead_root);
|
|
|
|
else
|
|
|
|
ret = btrfs_add_dead_root(dead_root, latest);
|
2007-06-22 12:16:25 -06:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
2008-06-26 08:34:20 -06:00
|
|
|
goto again;
|
2007-06-22 12:16:25 -06:00
|
|
|
next:
|
|
|
|
slot++;
|
|
|
|
path->slots[0]++;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
err:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-03-16 14:20:31 -06:00
|
|
|
int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
|
|
|
|
struct btrfs_key *key)
|
2007-03-13 14:47:54 -06:00
|
|
|
{
|
2007-04-02 09:20:42 -06:00
|
|
|
struct btrfs_path *path;
|
2007-03-13 14:47:54 -06:00
|
|
|
int ret;
|
2007-04-10 07:27:04 -06:00
|
|
|
u32 refs;
|
|
|
|
struct btrfs_root_item *ri;
|
2007-10-15 14:14:19 -06:00
|
|
|
struct extent_buffer *leaf;
|
2007-03-13 14:47:54 -06:00
|
|
|
|
2007-04-02 09:20:42 -06:00
|
|
|
path = btrfs_alloc_path();
|
|
|
|
BUG_ON(!path);
|
|
|
|
ret = btrfs_search_slot(trans, root, key, path, -1, 1);
|
2007-03-13 14:47:54 -06:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2007-12-21 14:27:24 -07:00
|
|
|
if (ret) {
|
|
|
|
btrfs_print_leaf(root, path->nodes[0]);
|
|
|
|
printk("failed to del %Lu %u %Lu\n", key->objectid, key->type, key->offset);
|
|
|
|
|
|
|
|
}
|
2007-03-13 14:47:54 -06:00
|
|
|
BUG_ON(ret != 0);
|
2007-10-15 14:14:19 -06:00
|
|
|
leaf = path->nodes[0];
|
|
|
|
ri = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_item);
|
2007-04-10 07:27:04 -06:00
|
|
|
|
2007-10-15 14:14:19 -06:00
|
|
|
refs = btrfs_disk_root_refs(leaf, ri);
|
2007-06-22 12:16:25 -06:00
|
|
|
BUG_ON(refs != 0);
|
|
|
|
ret = btrfs_del_item(trans, root, path);
|
2007-03-13 14:47:54 -06:00
|
|
|
out:
|
2007-04-02 09:20:42 -06:00
|
|
|
btrfs_release_path(root, path);
|
|
|
|
btrfs_free_path(path);
|
2007-03-13 14:47:54 -06:00
|
|
|
return ret;
|
|
|
|
}
|