leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename funcs and structs to btrfs

Browse Source 
Signed-off-by: Chris Mason <chris.mason@oracle.com>
This commit is contained in:
Chris Mason 2007-03-13 10:46:10 -04:00 committed by David Woodhouse
parent cf27e1eec0
commit 234b63a091
11 changed files with 454 additions and 447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

317
fs/btrfs/ctree.c
View File

@ -6,47 +6,47 @@
#include "disk-io.h"
#include "print-tree.h"
static int split_node(struct ctree_root *root, struct ctree_path *path,
static int split_node(struct btrfs_root *root, struct btrfs_path *path,
int level);
static int split_leaf(struct ctree_root *root, struct ctree_path *path,
static int split_leaf(struct btrfs_root *root, struct btrfs_path *path,
int data_size);
static int push_node_left(struct ctree_root *root, struct tree_buffer *dst,
struct tree_buffer *src);
static int balance_node_right(struct ctree_root *root,
struct tree_buffer *dst_buf,
struct tree_buffer *src_buf);
static int del_ptr(struct ctree_root *root, struct ctree_path *path, int level,
static int push_node_left(struct btrfs_root *root, struct btrfs_buffer *dst,
struct btrfs_buffer *src);
static int balance_node_right(struct btrfs_root *root,
struct btrfs_buffer *dst_buf,
struct btrfs_buffer *src_buf);
static int del_ptr(struct btrfs_root *root, struct btrfs_path *path, int level,
int slot);
inline void init_path(struct ctree_path *p)
inline void btrfs_init_path(struct btrfs_path *p)
{
memset(p, 0, sizeof(*p));
}
void release_path(struct ctree_root *root, struct ctree_path *p)
void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p)
{
int i;
for (i = 0; i < MAX_LEVEL; i++) {
for (i = 0; i < BTRFS_MAX_LEVEL; i++) {
if (!p->nodes[i])
break;
tree_block_release(root, p->nodes[i]);
btrfs_block_release(root, p->nodes[i]);
}
memset(p, 0, sizeof(*p));
}
int btrfs_cow_block(struct ctree_root *root,
struct tree_buffer *buf,
struct tree_buffer *parent,
int btrfs_cow_block(struct btrfs_root *root,
struct btrfs_buffer *buf,
struct btrfs_buffer *parent,
int parent_slot,
struct tree_buffer **cow_ret)
struct btrfs_buffer **cow_ret)
{
struct tree_buffer *cow;
struct btrfs_buffer *cow;
if (!list_empty(&buf->dirty)) {
*cow_ret = buf;
return 0;
}
cow = alloc_free_block(root);
cow = btrfs_alloc_free_block(root);
memcpy(&cow->node, &buf->node, sizeof(buf->node));
btrfs_set_header_blocknr(&cow->node.header, cow->blocknr);
*cow_ret = cow;
@ -55,15 +55,15 @@ int btrfs_cow_block(struct ctree_root *root,
root->node = cow;
cow->count++;
if (buf != root->commit_root)
free_extent(root, buf->blocknr, 1);
tree_block_release(root, buf);
btrfs_free_extent(root, buf->blocknr, 1);
btrfs_block_release(root, buf);
} else {
btrfs_set_node_blockptr(&parent->node, parent_slot,
cow->blocknr);
BUG_ON(list_empty(&parent->dirty));
free_extent(root, buf->blocknr, 1);
btrfs_free_extent(root, buf->blocknr, 1);
}
tree_block_release(root, buf);
btrfs_block_release(root, buf);
return 0;
}
@ -72,7 +72,7 @@ int btrfs_cow_block(struct ctree_root *root,
* this returns the address of the start of the last item,
* which is the stop of the leaf data stack
*/
static inline unsigned int leaf_data_end(struct leaf *leaf)
static inline unsigned int leaf_data_end(struct btrfs_leaf *leaf)
{
u32 nr = btrfs_header_nritems(&leaf->header);
if (nr == 0)
@ -85,7 +85,7 @@ static inline unsigned int leaf_data_end(struct leaf *leaf)
* the start of the leaf data. IOW, how much room
* the leaf has left for both items and data
*/
int leaf_free_space(struct leaf *leaf)
int btrfs_leaf_free_space(struct btrfs_leaf *leaf)
{
int data_end = leaf_data_end(leaf);
int nritems = btrfs_header_nritems(&leaf->header);
@ -117,11 +117,11 @@ int comp_keys(struct btrfs_disk_key *disk, struct btrfs_key *k2)
return 0;
}
int check_node(struct ctree_path *path, int level)
int check_node(struct btrfs_path *path, int level)
{
int i;
struct node *parent = NULL;
struct node *node = &path->nodes[level]->node;
struct btrfs_node *parent = NULL;
struct btrfs_node *node = &path->nodes[level]->node;
int parent_slot;
u32 nritems = btrfs_header_nritems(&node->header);
@ -146,18 +146,18 @@ int check_node(struct ctree_path *path, int level)
return 0;
}
int check_leaf(struct ctree_path *path, int level)
int check_leaf(struct btrfs_path *path, int level)
{
int i;
struct leaf *leaf = &path->nodes[level]->leaf;
struct node *parent = NULL;
struct btrfs_leaf *leaf = &path->nodes[level]->leaf;
struct btrfs_node *parent = NULL;
int parent_slot;
u32 nritems = btrfs_header_nritems(&leaf->header);
if (path->nodes[level + 1])
parent = &path->nodes[level + 1]->node;
parent_slot = path->slots[level + 1];
BUG_ON(leaf_free_space(leaf) < 0);
BUG_ON(btrfs_leaf_free_space(leaf) < 0);
if (nritems == 0)
return 0;
@ -186,7 +186,7 @@ int check_leaf(struct ctree_path *path, int level)
return 0;
}
int check_block(struct ctree_path *path, int level)
int check_block(struct btrfs_path *path, int level)
{
if (level == 0)
return check_leaf(path, level);
@ -233,10 +233,10 @@ int generic_bin_search(char *p, int item_size, struct btrfs_key *key,
* simple bin_search frontend that does the right thing for
* leaves vs nodes
*/
int bin_search(struct node *c, struct btrfs_key *key, int *slot)
int bin_search(struct btrfs_node *c, struct btrfs_key *key, int *slot)
{
if (btrfs_is_leaf(c)) {
struct leaf *l = (struct leaf *)c;
struct btrfs_leaf *l = (struct btrfs_leaf *)c;
return generic_bin_search((void *)l->items,
sizeof(struct btrfs_item),
key, btrfs_header_nritems(&c->header),
@ -250,11 +250,11 @@ int bin_search(struct node *c, struct btrfs_key *key, int *slot)
return -1;
}
struct tree_buffer *read_node_slot(struct ctree_root *root,
struct tree_buffer *parent_buf,
struct btrfs_buffer *read_node_slot(struct btrfs_root *root,
struct btrfs_buffer *parent_buf,
int slot)
{
struct node *node = &parent_buf->node;
struct btrfs_node *node = &parent_buf->node;
if (slot < 0)
return NULL;
if (slot >= btrfs_header_nritems(&node->header))
@ -262,17 +262,17 @@ struct tree_buffer *read_node_slot(struct ctree_root *root,
return read_tree_block(root, btrfs_node_blockptr(node, slot));
}
static int balance_level(struct ctree_root *root, struct ctree_path *path,
static int balance_level(struct btrfs_root *root, struct btrfs_path *path,
int level)
{
struct tree_buffer *right_buf;
struct tree_buffer *mid_buf;
struct tree_buffer *left_buf;
struct tree_buffer *parent_buf = NULL;
struct node *right = NULL;
struct node *mid;
struct node *left = NULL;
struct node *parent = NULL;
struct btrfs_buffer *right_buf;
struct btrfs_buffer *mid_buf;
struct btrfs_buffer *left_buf;
struct btrfs_buffer *parent_buf = NULL;
struct btrfs_node *right = NULL;
struct btrfs_node *mid;
struct btrfs_node *left = NULL;
struct btrfs_node *parent = NULL;
int ret = 0;
int wret;
int pslot;
@ -286,12 +286,12 @@ static int balance_level(struct ctree_root *root, struct ctree_path *path,
mid = &mid_buf->node;
orig_ptr = btrfs_node_blockptr(mid, orig_slot);
if (level < MAX_LEVEL - 1)
if (level < BTRFS_MAX_LEVEL - 1)
parent_buf = path->nodes[level + 1];
pslot = path->slots[level + 1];
if (!parent_buf) {
struct tree_buffer *child;
struct btrfs_buffer *child;
u64 blocknr = mid_buf->blocknr;
if (btrfs_header_nritems(&mid->header) != 1)
@ -303,11 +303,11 @@ static int balance_level(struct ctree_root *root, struct ctree_path *path,
root->node = child;
path->nodes[level] = NULL;
/* once for the path */
tree_block_release(root, mid_buf);
btrfs_block_release(root, mid_buf);
/* once for the root ptr */
tree_block_release(root, mid_buf);
btrfs_block_release(root, mid_buf);
clean_tree_block(root, mid_buf);
return free_extent(root, blocknr, 1);
return btrfs_free_extent(root, blocknr, 1);
}
parent = &parent_buf->node;
@ -340,14 +340,14 @@ static int balance_level(struct ctree_root *root, struct ctree_path *path,
ret = wret;
if (btrfs_header_nritems(&right->header) == 0) {
u64 blocknr = right_buf->blocknr;
tree_block_release(root, right_buf);
btrfs_block_release(root, right_buf);
clean_tree_block(root, right_buf);
right_buf = NULL;
right = NULL;
wret = del_ptr(root, path, level + 1, pslot + 1);
if (wret)
ret = wret;
wret = free_extent(root, blocknr, 1);
wret = btrfs_free_extent(root, blocknr, 1);
if (wret)
ret = wret;
} else {
@ -375,14 +375,14 @@ static int balance_level(struct ctree_root *root, struct ctree_path *path,
if (btrfs_header_nritems(&mid->header) == 0) {
/* we've managed to empty the middle node, drop it */
u64 blocknr = mid_buf->blocknr;
tree_block_release(root, mid_buf);
btrfs_block_release(root, mid_buf);
clean_tree_block(root, mid_buf);
mid_buf = NULL;
mid = NULL;
wret = del_ptr(root, path, level + 1, pslot);
if (wret)
ret = wret;
wret = free_extent(root, blocknr, 1);
wret = btrfs_free_extent(root, blocknr, 1);
if (wret)
ret = wret;
} else {
@ -400,7 +400,7 @@ static int balance_level(struct ctree_root *root, struct ctree_path *path,
path->slots[level + 1] -= 1;
path->slots[level] = orig_slot;
if (mid_buf)
tree_block_release(root, mid_buf);
btrfs_block_release(root, mid_buf);
} else {
orig_slot -= btrfs_header_nritems(&left->header);
path->slots[level] = orig_slot;
@ -413,9 +413,9 @@ static int balance_level(struct ctree_root *root, struct ctree_path *path,
BUG();
if (right_buf)
tree_block_release(root, right_buf);
btrfs_block_release(root, right_buf);
if (left_buf)
tree_block_release(root, left_buf);
btrfs_block_release(root, left_buf);
return ret;
}
@ -432,12 +432,12 @@ static int balance_level(struct ctree_root *root, struct ctree_path *path,
* tree. if ins_len < 0, nodes will be merged as we walk down the tree (if
* possible)
*/
int search_slot(struct ctree_root *root, struct btrfs_key *key,
struct ctree_path *p, int ins_len, int cow)
int btrfs_search_slot(struct btrfs_root *root, struct btrfs_key *key,
struct btrfs_path *p, int ins_len, int cow)
{
struct tree_buffer *b;
struct tree_buffer *cow_buf;
struct node *c;
struct btrfs_buffer *b;
struct btrfs_buffer *cow_buf;
struct btrfs_node *c;
int slot;
int ret;
int level;
@ -486,9 +486,9 @@ again:
}
b = read_tree_block(root, btrfs_node_blockptr(c, slot));
} else {
struct leaf *l = (struct leaf *)c;
struct btrfs_leaf *l = (struct btrfs_leaf *)c;
p->slots[level] = slot;
if (ins_len > 0 && leaf_free_space(l) <
if (ins_len > 0 && btrfs_leaf_free_space(l) <
sizeof(struct btrfs_item) + ins_len) {
int sret = split_leaf(root, p, ins_len);
BUG_ON(sret > 0);
@ -513,14 +513,14 @@ again:
* If this fails to write a tree block, it returns -1, but continues
* fixing up the blocks in ram so the tree is consistent.
*/
static int fixup_low_keys(struct ctree_root *root,
struct ctree_path *path, struct btrfs_disk_key *key,
static int fixup_low_keys(struct btrfs_root *root,
struct btrfs_path *path, struct btrfs_disk_key *key,
int level)
{
int i;
int ret = 0;
for (i = level; i < MAX_LEVEL; i++) {
struct node *t;
for (i = level; i < BTRFS_MAX_LEVEL; i++) {
struct btrfs_node *t;
int tslot = path->slots[i];
if (!path->nodes[i])
break;
@ -540,11 +540,11 @@ static int fixup_low_keys(struct ctree_root *root,
* 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.
*/
static int push_node_left(struct ctree_root *root, struct tree_buffer *dst_buf,
struct tree_buffer *src_buf)
static int push_node_left(struct btrfs_root *root, struct btrfs_buffer *dst_buf,
struct btrfs_buffer *src_buf)
{
struct node *src = &src_buf->node;
struct node *dst = &dst_buf->node;
struct btrfs_node *src = &src_buf->node;
struct btrfs_node *dst = &dst_buf->node;
int push_items = 0;
int src_nritems;
int dst_nritems;
@ -587,12 +587,12 @@ static int push_node_left(struct ctree_root *root, struct tree_buffer *dst_buf,
*
* this will only push up to 1/2 the contents of the left node over
*/
static int balance_node_right(struct ctree_root *root,
struct tree_buffer *dst_buf,
struct tree_buffer *src_buf)
static int balance_node_right(struct btrfs_root *root,
struct btrfs_buffer *dst_buf,
struct btrfs_buffer *src_buf)
{
struct node *src = &src_buf->node;
struct node *dst = &dst_buf->node;
struct btrfs_node *src = &src_buf->node;
struct btrfs_node *dst = &dst_buf->node;
int push_items = 0;
int max_push;
int src_nritems;
@ -637,18 +637,18 @@ static int balance_node_right(struct ctree_root *root,
*
* returns zero on success or < 0 on failure.
*/
static int insert_new_root(struct ctree_root *root,
struct ctree_path *path, int level)
static int insert_new_root(struct btrfs_root *root,
struct btrfs_path *path, int level)
{
struct tree_buffer *t;
struct node *lower;
struct node *c;
struct btrfs_buffer *t;
struct btrfs_node *lower;
struct btrfs_node *c;
struct btrfs_disk_key *lower_key;
BUG_ON(path->nodes[level]);
BUG_ON(path->nodes[level-1] != root->node);
t = alloc_free_block(root);
t = btrfs_alloc_free_block(root);
c = &t->node;
memset(c, 0, sizeof(c));
btrfs_set_header_nritems(&c->header, 1);
@ -658,13 +658,13 @@ static int insert_new_root(struct ctree_root *root,
btrfs_header_parentid(&root->node->node.header));
lower = &path->nodes[level-1]->node;
if (btrfs_is_leaf(lower))
lower_key = &((struct leaf *)lower)->items[0].key;
lower_key = &((struct btrfs_leaf *)lower)->items[0].key;
else
lower_key = lower->keys;
memcpy(c->keys, lower_key, sizeof(struct btrfs_disk_key));
btrfs_set_node_blockptr(c, 0, path->nodes[level - 1]->blocknr);
/* the super has an extra ref to root->node */
tree_block_release(root, root->node);
btrfs_block_release(root, root->node);
root->node = t;
t->count++;
path->nodes[level] = t;
@ -681,11 +681,11 @@ static int insert_new_root(struct ctree_root *root,
*
* returns zero on success and < 0 on any error
*/
static int insert_ptr(struct ctree_root *root,
struct ctree_path *path, struct btrfs_disk_key *key,
static int insert_ptr(struct btrfs_root *root,
struct btrfs_path *path, struct btrfs_disk_key *key,
u64 blocknr, int slot, int level)
{
struct node *lower;
struct btrfs_node *lower;
int nritems;
BUG_ON(!path->nodes[level]);
@ -719,13 +719,13 @@ static int insert_ptr(struct ctree_root *root,
*
* returns 0 on success and < 0 on failure
*/
static int split_node(struct ctree_root *root, struct ctree_path *path,
static int split_node(struct btrfs_root *root, struct btrfs_path *path,
int level)
{
struct tree_buffer *t;
struct node *c;
struct tree_buffer *split_buffer;
struct node *split;
struct btrfs_buffer *t;
struct btrfs_node *c;
struct btrfs_buffer *split_buffer;
struct btrfs_node *split;
int mid;
int ret;
int wret;
@ -740,7 +740,7 @@ static int split_node(struct ctree_root *root, struct ctree_path *path,
return ret;
}
c_nritems = btrfs_header_nritems(&c->header);
split_buffer = alloc_free_block(root);
split_buffer = btrfs_alloc_free_block(root);
split = &split_buffer->node;
btrfs_set_header_flags(&split->header, btrfs_header_flags(&c->header));
btrfs_set_header_blocknr(&split->header, split_buffer->blocknr);
@ -763,11 +763,11 @@ static int split_node(struct ctree_root *root, struct ctree_path *path,
if (path->slots[level] >= mid) {
path->slots[level] -= mid;
tree_block_release(root, t);
btrfs_block_release(root, t);
path->nodes[level] = split_buffer;
path->slots[level + 1] += 1;
} else {
tree_block_release(root, split_buffer);
btrfs_block_release(root, split_buffer);
}
return ret;
}
@ -777,7 +777,7 @@ static int split_node(struct ctree_root *root, struct ctree_path *path,
* 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
*/
static int leaf_space_used(struct leaf *l, int start, int nr)
static int leaf_space_used(struct btrfs_leaf *l, int start, int nr)
{
int data_len;
int end = start + nr - 1;
@ -797,14 +797,14 @@ static int leaf_space_used(struct leaf *l, int start, int nr)
* 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 ctree_root *root, struct ctree_path *path,
static int push_leaf_right(struct btrfs_root *root, struct btrfs_path *path,
int data_size)
{
struct tree_buffer *left_buf = path->nodes[0];
struct leaf *left = &left_buf->leaf;
struct leaf *right;
struct tree_buffer *right_buf;
struct tree_buffer *upper;
struct btrfs_buffer *left_buf = path->nodes[0];
struct btrfs_leaf *left = &left_buf->leaf;
struct btrfs_leaf *right;
struct btrfs_buffer *right_buf;
struct btrfs_buffer *upper;
int slot;
int i;
int free_space;
@ -825,17 +825,17 @@ static int push_leaf_right(struct ctree_root *root, struct ctree_path *path,
right_buf = read_tree_block(root, btrfs_node_blockptr(&upper->node,
slot + 1));
right = &right_buf->leaf;
free_space = leaf_free_space(right);
free_space = btrfs_leaf_free_space(right);
if (free_space < data_size + sizeof(struct btrfs_item)) {
tree_block_release(root, right_buf);
btrfs_block_release(root, right_buf);
return 1;
}
/* cow and double check */
btrfs_cow_block(root, right_buf, upper, slot + 1, &right_buf);
right = &right_buf->leaf;
free_space = leaf_free_space(right);
free_space = btrfs_leaf_free_space(right);
if (free_space < data_size + sizeof(struct btrfs_item)) {
tree_block_release(root, right_buf);
btrfs_block_release(root, right_buf);
return 1;
}
@ -851,7 +851,7 @@ static int push_leaf_right(struct ctree_root *root, struct ctree_path *path,
push_space += btrfs_item_size(item) + sizeof(*item);
}
if (push_items == 0) {
tree_block_release(root, right_buf);
btrfs_block_release(root, right_buf);
return 1;
}
right_nritems = btrfs_header_nritems(&right->header);
@ -893,11 +893,11 @@ static int push_leaf_right(struct ctree_root *root, struct ctree_path *path,
/* then fixup the leaf pointer in the path */
if (path->slots[0] >= left_nritems) {
path->slots[0] -= left_nritems;
tree_block_release(root, path->nodes[0]);
btrfs_block_release(root, path->nodes[0]);
path->nodes[0] = right_buf;
path->slots[1] += 1;
} else {
tree_block_release(root, right_buf);
btrfs_block_release(root, right_buf);
}
return 0;
}
@ -905,13 +905,13 @@ static int push_leaf_right(struct ctree_root *root, struct ctree_path *path,
* 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 ctree_root *root, struct ctree_path *path,
static int push_leaf_left(struct btrfs_root *root, struct btrfs_path *path,
int data_size)
{
struct tree_buffer *right_buf = path->nodes[0];
struct leaf *right = &right_buf->leaf;
struct tree_buffer *t;
struct leaf *left;
struct btrfs_buffer *right_buf = path->nodes[0];
struct btrfs_leaf *right = &right_buf->leaf;
struct btrfs_buffer *t;
struct btrfs_leaf *left;
int slot;
int i;
int free_space;
@ -932,18 +932,18 @@ static int push_leaf_left(struct ctree_root *root, struct ctree_path *path,
t = read_tree_block(root, btrfs_node_blockptr(&path->nodes[1]->node,
slot - 1));
left = &t->leaf;
free_space = leaf_free_space(left);
free_space = btrfs_leaf_free_space(left);
if (free_space < data_size + sizeof(struct btrfs_item)) {
tree_block_release(root, t);
btrfs_block_release(root, t);
return 1;
}
/* cow and double check */
btrfs_cow_block(root, t, path->nodes[1], slot - 1, &t);
left = &t->leaf;
free_space = leaf_free_space(left);
free_space = btrfs_leaf_free_space(left);
if (free_space < data_size + sizeof(struct btrfs_item)) {
tree_block_release(root, t);
btrfs_block_release(root, t);
return 1;
}
@ -958,7 +958,7 @@ static int push_leaf_left(struct ctree_root *root, struct ctree_path *path,
push_space += btrfs_item_size(item) + sizeof(*item);
}
if (push_items == 0) {
tree_block_release(root, t);
btrfs_block_release(root, t);
return 1;
}
/* push data from right to left */
@ -1009,11 +1009,11 @@ static int push_leaf_left(struct ctree_root *root, struct ctree_path *path,
/* then fixup the leaf pointer in the path */
if (path->slots[0] < push_items) {
path->slots[0] += old_left_nritems;
tree_block_release(root, path->nodes[0]);
btrfs_block_release(root, path->nodes[0]);
path->nodes[0] = t;
path->slots[1] -= 1;
} else {
tree_block_release(root, t);
btrfs_block_release(root, t);
path->slots[0] -= push_items;
}
BUG_ON(path->slots[0] < 0);
@ -1026,16 +1026,16 @@ static int push_leaf_left(struct ctree_root *root, struct ctree_path *path,
*
* returns 0 if all went well and < 0 on failure.
*/
static int split_leaf(struct ctree_root *root, struct ctree_path *path,
static int split_leaf(struct btrfs_root *root, struct btrfs_path *path,
int data_size)
{
struct tree_buffer *l_buf;
struct leaf *l;
struct btrfs_buffer *l_buf;
struct btrfs_leaf *l;
u32 nritems;
int mid;
int slot;
struct leaf *right;
struct tree_buffer *right_buffer;
struct btrfs_leaf *right;
struct btrfs_buffer *right_buffer;
int space_needed = data_size + sizeof(struct btrfs_item);
int data_copy_size;
int rt_data_off;
@ -1047,7 +1047,7 @@ static int split_leaf(struct ctree_root *root, struct ctree_path *path,
l = &l_buf->leaf;
/* did the pushes work? */
if (leaf_free_space(l) >= sizeof(struct btrfs_item) + data_size)
if (btrfs_leaf_free_space(l) >= sizeof(struct btrfs_item) + data_size)
return 0;
if (!path->nodes[1]) {
@ -1058,7 +1058,7 @@ static int split_leaf(struct ctree_root *root, struct ctree_path *path,
slot = path->slots[0];
nritems = btrfs_header_nritems(&l->header);
mid = (nritems + 1)/ 2;
right_buffer = alloc_free_block(root);
right_buffer = btrfs_alloc_free_block(root);
BUG_ON(!right_buffer);
BUG_ON(mid == nritems);
right = &right_buffer->leaf;
@ -1101,12 +1101,12 @@ static int split_leaf(struct ctree_root *root, struct ctree_path *path,
BUG_ON(list_empty(&l_buf->dirty));
BUG_ON(path->slots[0] != slot);
if (mid <= slot) {
tree_block_release(root, path->nodes[0]);
btrfs_block_release(root, path->nodes[0]);
path->nodes[0] = right_buffer;
path->slots[0] -= mid;
path->slots[1] += 1;
} else
tree_block_release(root, right_buffer);
btrfs_block_release(root, right_buffer);
BUG_ON(path->slots[0] < 0);
return ret;
}
@ -1115,17 +1115,17 @@ static int split_leaf(struct ctree_root *root, struct ctree_path *path,
* 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.
*/
int insert_item(struct ctree_root *root, struct btrfs_key *cpu_key,
int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
void *data, int data_size)
{
int ret = 0;
int slot;
int slot_orig;
struct leaf *leaf;
struct tree_buffer *leaf_buf;
struct btrfs_leaf *leaf;
struct btrfs_buffer *leaf_buf;
u32 nritems;
unsigned int data_end;
struct ctree_path path;
struct btrfs_path path;
struct btrfs_disk_key disk_key;
btrfs_cpu_key_to_disk(&disk_key, cpu_key);
@ -1133,10 +1133,10 @@ int insert_item(struct ctree_root *root, struct btrfs_key *cpu_key,
/* create a root if there isn't one */
if (!root->node)
BUG();
init_path(&path);
ret = search_slot(root, cpu_key, &path, data_size, 1);
btrfs_init_path(&path);
ret = btrfs_search_slot(root, cpu_key, &path, data_size, 1);
if (ret == 0) {
release_path(root, &path);
btrfs_release_path(root, &path);
return -EEXIST;
}
if (ret < 0)
@ -1149,7 +1149,8 @@ int insert_item(struct ctree_root *root, struct btrfs_key *cpu_key,
nritems = btrfs_header_nritems(&leaf->header);
data_end = leaf_data_end(leaf);
if (leaf_free_space(leaf) < sizeof(struct btrfs_item) + data_size)
if (btrfs_leaf_free_space(leaf) <
sizeof(struct btrfs_item) + data_size)
BUG();
slot = path.slots[0];
@ -1190,11 +1191,11 @@ int insert_item(struct ctree_root *root, struct btrfs_key *cpu_key,
ret = fixup_low_keys(root, &path, &disk_key, 1);
BUG_ON(list_empty(&leaf_buf->dirty));
if (leaf_free_space(leaf) < 0)
if (btrfs_leaf_free_space(leaf) < 0)
BUG();
check_leaf(&path, 0);
out:
release_path(root, &path);
btrfs_release_path(root, &path);
return ret;
}
@ -1205,11 +1206,11 @@ out:
* continuing all the way the root if required. The root is converted into
* a leaf if all the nodes are emptied.
*/
static int del_ptr(struct ctree_root *root, struct ctree_path *path, int level,
static int del_ptr(struct btrfs_root *root, struct btrfs_path *path, int level,
int slot)
{
struct node *node;
struct tree_buffer *parent = path->nodes[level];
struct btrfs_node *node;
struct btrfs_buffer *parent = path->nodes[level];
u32 nritems;
int ret = 0;
int wret;
@ -1242,11 +1243,11 @@ static int del_ptr(struct ctree_root *root, struct ctree_path *path, int level,
* delete the item at the leaf level in path. If that empties
* the leaf, remove it from the tree
*/
int del_item(struct ctree_root *root, struct ctree_path *path)
int btrfs_del_item(struct btrfs_root *root, struct btrfs_path *path)
{
int slot;
struct leaf *leaf;
struct tree_buffer *leaf_buf;
struct btrfs_leaf *leaf;
struct btrfs_buffer *leaf_buf;
int doff;
int dsize;
int ret = 0;
@ -1286,7 +1287,7 @@ int del_item(struct ctree_root *root, struct ctree_path *path)
wret = del_ptr(root, path, 1, path->slots[1]);
if (wret)
ret = wret;
wret = free_extent(root, leaf_buf->blocknr, 1);
wret = btrfs_free_extent(root, leaf_buf->blocknr, 1);
if (wret)
ret = wret;
}
@ -1323,12 +1324,12 @@ int del_item(struct ctree_root *root, struct ctree_path *path)
wret = del_ptr(root, path, 1, slot);
if (wret)
ret = wret;
tree_block_release(root, leaf_buf);
wret = free_extent(root, blocknr, 1);
btrfs_block_release(root, leaf_buf);
wret = btrfs_free_extent(root, blocknr, 1);
if (wret)
ret = wret;
} else {
tree_block_release(root, leaf_buf);
btrfs_block_release(root, leaf_buf);
}
}
}
@ -1340,15 +1341,15 @@ int del_item(struct ctree_root *root, struct ctree_path *path)
* returns 0 if it found something or 1 if there are no greater leaves.
* returns < 0 on io errors.
*/
int next_leaf(struct ctree_root *root, struct ctree_path *path)
int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
{
int slot;
int level = 1;
u64 blocknr;
struct tree_buffer *c;
struct tree_buffer *next = NULL;
struct btrfs_buffer *c;
struct btrfs_buffer *next = NULL;
while(level < MAX_LEVEL) {
while(level < BTRFS_MAX_LEVEL) {
if (!path->nodes[level])
return 1;
slot = path->slots[level] + 1;
@ -1359,7 +1360,7 @@ int next_leaf(struct ctree_root *root, struct ctree_path *path)
}
blocknr = btrfs_node_blockptr(&c->node, slot);
if (next)
tree_block_release(root, next);
btrfs_block_release(root, next);
next = read_tree_block(root, blocknr);
break;
}
@ -1367,7 +1368,7 @@ int next_leaf(struct ctree_root *root, struct ctree_path *path)
while(1) {
level--;
c = path->nodes[level];
tree_block_release(root, c);
btrfs_block_release(root, c);
path->nodes[level] = next;
path->slots[level] = 0;
if (!level)

95
fs/btrfs/ctree.h
View File

@ -1,10 +1,10 @@
#ifndef __CTREE__
#define __CTREE__
#ifndef __BTRFS__
#define __BTRFS__
#include "list.h"
#include "kerncompat.h"
#define CTREE_BLOCKSIZE 1024
#define BTRFS_BLOCKSIZE 1024
/*
* the key defines the order in the tree, and so it also defines (optimal)
@ -46,21 +46,21 @@ struct btrfs_header {
/* generation flags to be added */
} __attribute__ ((__packed__));
#define MAX_LEVEL 8
#define NODEPTRS_PER_BLOCK ((CTREE_BLOCKSIZE - sizeof(struct btrfs_header)) / \
#define BTRFS_MAX_LEVEL 8
#define NODEPTRS_PER_BLOCK ((BTRFS_BLOCKSIZE - sizeof(struct btrfs_header)) / \
(sizeof(struct btrfs_disk_key) + sizeof(u64)))
struct tree_buffer;
struct btrfs_buffer;
/*
* in ram representation of the tree. extent_root is used for all allocations
* and for the extent tree extent_root root. current_insert is used
* only for the extent tree.
*/
struct ctree_root {
struct tree_buffer *node;
struct tree_buffer *commit_root;
struct ctree_root *extent_root;
struct btrfs_root {
struct btrfs_buffer *node;
struct btrfs_buffer *commit_root;
struct btrfs_root *extent_root;
struct btrfs_key current_insert;
struct btrfs_key last_insert;
int fp;
@ -74,7 +74,7 @@ struct ctree_root {
/*
* describes a tree on disk
*/
struct ctree_root_info {
struct btrfs_root_info {
u64 fsid[2]; /* FS specific uuid */
u64 blocknr; /* blocknr of this block */
u64 objectid; /* inode number of this root */
@ -88,9 +88,9 @@ struct ctree_root_info {
* the super block basically lists the main trees of the FS
* it currently lacks any block count etc etc
*/
struct ctree_super_block {
struct ctree_root_info root_info;
struct ctree_root_info extent_info;
struct btrfs_super_block {
struct btrfs_root_info root_info;
struct btrfs_root_info extent_info;
} __attribute__ ((__packed__));
/*
@ -111,13 +111,13 @@ struct btrfs_item {
* The data is separate from the items to get the keys closer together
* during searches.
*/
#define LEAF_DATA_SIZE (CTREE_BLOCKSIZE - sizeof(struct btrfs_header))
struct leaf {
#define LEAF_DATA_SIZE (BTRFS_BLOCKSIZE - sizeof(struct btrfs_header))
struct btrfs_leaf {
struct btrfs_header header;
union {
struct btrfs_item items[LEAF_DATA_SIZE/
sizeof(struct btrfs_item)];
u8 data[CTREE_BLOCKSIZE-sizeof(struct btrfs_header)];
u8 data[BTRFS_BLOCKSIZE - sizeof(struct btrfs_header)];
};
} __attribute__ ((__packed__));
@ -125,7 +125,7 @@ struct leaf {
* all non-leaf blocks are nodes, they hold only keys and pointers to
* other blocks
*/
struct node {
struct btrfs_node {
struct btrfs_header header;
struct btrfs_disk_key keys[NODEPTRS_PER_BLOCK];
__le64 blockptrs[NODEPTRS_PER_BLOCK];
@ -135,50 +135,51 @@ struct node {
* items in the extent btree are used to record the objectid of the
* owner of the block and the number of references
*/
struct extent_item {
struct btrfs_extent_item {
__le32 refs;
__le64 owner;
} __attribute__ ((__packed__));
/*
* ctree_paths remember the path taken from the root down to the leaf.
* level 0 is always the leaf, and nodes[1...MAX_LEVEL] will point
* btrfs_paths remember the path taken from the root down to the leaf.
* level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
* to any other levels that are present.
*
* The slots array records the index of the item or block pointer
* used while walking the tree.
*/
struct ctree_path {
struct tree_buffer *nodes[MAX_LEVEL];
int slots[MAX_LEVEL];
struct btrfs_path {
struct btrfs_buffer *nodes[BTRFS_MAX_LEVEL];
int slots[BTRFS_MAX_LEVEL];
};
static inline u64 btrfs_extent_owner(struct extent_item *ei)
static inline u64 btrfs_extent_owner(struct btrfs_extent_item *ei)
{
return le64_to_cpu(ei->owner);
}
static inline void btrfs_set_extent_owner(struct extent_item *ei, u64 val)
static inline void btrfs_set_extent_owner(struct btrfs_extent_item *ei, u64 val)
{
ei->owner = cpu_to_le64(val);
}
static inline u32 btrfs_extent_refs(struct extent_item *ei)
static inline u32 btrfs_extent_refs(struct btrfs_extent_item *ei)
{
return le32_to_cpu(ei->refs);
}
static inline void btrfs_set_extent_refs(struct extent_item *ei, u32 val)
static inline void btrfs_set_extent_refs(struct btrfs_extent_item *ei, u32 val)
{
ei->refs = cpu_to_le32(val);
}
static inline u64 btrfs_node_blockptr(struct node *n, int nr)
static inline u64 btrfs_node_blockptr(struct btrfs_node *n, int nr)
{
return le64_to_cpu(n->blockptrs[nr]);
}
static inline void btrfs_set_node_blockptr(struct node *n, int nr, u64 val)
static inline void btrfs_set_node_blockptr(struct btrfs_node *n, int nr,
u64 val)
{
n->blockptrs[nr] = cpu_to_le64(val);
}
@ -300,34 +301,34 @@ static inline void btrfs_set_header_flags(struct btrfs_header *h, u16 val)
static inline int btrfs_header_level(struct btrfs_header *h)
{
return btrfs_header_flags(h) & (MAX_LEVEL - 1);
return btrfs_header_flags(h) & (BTRFS_MAX_LEVEL - 1);
}
static inline void btrfs_set_header_level(struct btrfs_header *h, int level)
{
u16 flags;
BUG_ON(level > MAX_LEVEL);
flags = btrfs_header_flags(h) & ~(MAX_LEVEL - 1);
BUG_ON(level > BTRFS_MAX_LEVEL);
flags = btrfs_header_flags(h) & ~(BTRFS_MAX_LEVEL - 1);
btrfs_set_header_flags(h, flags | level);
}
static inline int btrfs_is_leaf(struct node *n)
static inline int btrfs_is_leaf(struct btrfs_node *n)
{
return (btrfs_header_level(&n->header) == 0);
}
struct tree_buffer *alloc_free_block(struct ctree_root *root);
int btrfs_inc_ref(struct ctree_root *root, struct tree_buffer *buf);
int free_extent(struct ctree_root *root, u64 blocknr, u64 num_blocks);
int search_slot(struct ctree_root *root, struct btrfs_key *key,
struct ctree_path *p, int ins_len, int cow);
void release_path(struct ctree_root *root, struct ctree_path *p);
void init_path(struct ctree_path *p);
int del_item(struct ctree_root *root, struct ctree_path *path);
int insert_item(struct ctree_root *root, struct btrfs_key *key,
struct btrfs_buffer *btrfs_alloc_free_block(struct btrfs_root *root);
int btrfs_inc_ref(struct btrfs_root *root, struct btrfs_buffer *buf);
int btrfs_free_extent(struct btrfs_root *root, u64 blocknr, u64 num_blocks);
int btrfs_search_slot(struct btrfs_root *root, struct btrfs_key *key,
struct btrfs_path *p, int ins_len, int cow);
void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p);
void btrfs_init_path(struct btrfs_path *p);
int btrfs_del_item(struct btrfs_root *root, struct btrfs_path *path);
int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *key,
void *data, int data_size);
int next_leaf(struct ctree_root *root, struct ctree_path *path);
int leaf_free_space(struct leaf *leaf);
int btrfs_drop_snapshot(struct ctree_root *root, struct tree_buffer *snap);
int btrfs_finish_extent_commit(struct ctree_root *root);
int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
int btrfs_leaf_free_space(struct btrfs_leaf *leaf);
int btrfs_drop_snapshot(struct btrfs_root *root, struct btrfs_buffer *snap);
int btrfs_finish_extent_commit(struct btrfs_root *root);
#endif

8
fs/btrfs/debug-tree.c
View File

@ -7,13 +7,13 @@
#include "print-tree.h"
int main(int ac, char **av) {
struct ctree_super_block super;
struct ctree_root *root;
struct btrfs_super_block super;
struct btrfs_root *root;
radix_tree_init();
root = open_ctree("dbfile", &super);
printf("root tree\n");
print_tree(root, root->node);
btrfs_print_tree(root, root->node);
printf("map tree\n");
print_tree(root->extent_root, root->extent_root->node);
btrfs_print_tree(root->extent_root, root->extent_root->node);
return 0;
}

106
fs/btrfs/disk-io.c
View File

@ -13,7 +13,7 @@
static int allocated_blocks = 0;
int cache_max = 10000;
static int check_tree_block(struct ctree_root *root, struct tree_buffer *buf)
static int check_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf)
{
if (buf->blocknr != btrfs_header_blocknr(&buf->node.header))
BUG();
@ -23,18 +23,18 @@ static int check_tree_block(struct ctree_root *root, struct tree_buffer *buf)
return 0;
}
static int free_some_buffers(struct ctree_root *root)
static int free_some_buffers(struct btrfs_root *root)
{
struct list_head *node, *next;
struct tree_buffer *b;
struct btrfs_buffer *b;
if (root->cache_size < cache_max)
return 0;
list_for_each_safe(node, next, &root->cache) {
b = list_entry(node, struct tree_buffer, cache);
b = list_entry(node, struct btrfs_buffer, cache);
if (b->count == 1) {
BUG_ON(!list_empty(&b->dirty));
list_del_init(&b->cache);
tree_block_release(root, b);
btrfs_block_release(root, b);
if (root->cache_size < cache_max)
break;
}
@ -42,11 +42,11 @@ static int free_some_buffers(struct ctree_root *root)
return 0;
}
struct tree_buffer *alloc_tree_block(struct ctree_root *root, u64 blocknr)
struct btrfs_buffer *alloc_tree_block(struct btrfs_root *root, u64 blocknr)
{
struct tree_buffer *buf;
struct btrfs_buffer *buf;
int ret;
buf = malloc(sizeof(struct tree_buffer));
buf = malloc(sizeof(struct btrfs_buffer));
if (!buf)
return buf;
allocated_blocks++;
@ -66,9 +66,9 @@ struct tree_buffer *alloc_tree_block(struct ctree_root *root, u64 blocknr)
return buf;
}
struct tree_buffer *find_tree_block(struct ctree_root *root, u64 blocknr)
struct btrfs_buffer *find_tree_block(struct btrfs_root *root, u64 blocknr)
{
struct tree_buffer *buf;
struct btrfs_buffer *buf;
buf = radix_tree_lookup(&root->cache_radix, blocknr);
if (buf) {
buf->count++;
@ -82,10 +82,10 @@ struct tree_buffer *find_tree_block(struct ctree_root *root, u64 blocknr)
return buf;
}
struct tree_buffer *read_tree_block(struct ctree_root *root, u64 blocknr)
struct btrfs_buffer *read_tree_block(struct btrfs_root *root, u64 blocknr)
{
loff_t offset = blocknr * CTREE_BLOCKSIZE;
struct tree_buffer *buf;
loff_t offset = blocknr * BTRFS_BLOCKSIZE;
struct btrfs_buffer *buf;
int ret;
buf = radix_tree_lookup(&root->cache_radix, blocknr);
@ -95,8 +95,8 @@ struct tree_buffer *read_tree_block(struct ctree_root *root, u64 blocknr)
buf = alloc_tree_block(root, blocknr);
if (!buf)
return NULL;
ret = pread(root->fp, &buf->node, CTREE_BLOCKSIZE, offset);
if (ret != CTREE_BLOCKSIZE) {
ret = pread(root->fp, &buf->node, BTRFS_BLOCKSIZE, offset);
if (ret != BTRFS_BLOCKSIZE) {
free(buf);
return NULL;
}
@ -106,7 +106,7 @@ struct tree_buffer *read_tree_block(struct ctree_root *root, u64 blocknr)
return buf;
}
int dirty_tree_block(struct ctree_root *root, struct tree_buffer *buf)
int dirty_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf)
{
if (!list_empty(&buf->dirty))
return 0;
@ -115,46 +115,47 @@ int dirty_tree_block(struct ctree_root *root, struct tree_buffer *buf)
return 0;
}
int clean_tree_block(struct ctree_root *root, struct tree_buffer *buf)
int clean_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf)
{
if (!list_empty(&buf->dirty)) {
list_del_init(&buf->dirty);
tree_block_release(root, buf);
btrfs_block_release(root, buf);
}
return 0;
}
int write_tree_block(struct ctree_root *root, struct tree_buffer *buf)
int write_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf)
{
u64 blocknr = buf->blocknr;
loff_t offset = blocknr * CTREE_BLOCKSIZE;
loff_t offset = blocknr * BTRFS_BLOCKSIZE;
int ret;
if (buf->blocknr != btrfs_header_blocknr(&buf->node.header))
BUG();
ret = pwrite(root->fp, &buf->node, CTREE_BLOCKSIZE, offset);
if (ret != CTREE_BLOCKSIZE)
ret = pwrite(root->fp, &buf->node, BTRFS_BLOCKSIZE, offset);
if (ret != BTRFS_BLOCKSIZE)
return ret;
return 0;
}
static int __commit_transaction(struct ctree_root *root)
static int __commit_transaction(struct btrfs_root *root)
{
struct tree_buffer *b;
struct btrfs_buffer *b;
int ret = 0;
int wret;
while(!list_empty(&root->trans)) {
b = list_entry(root->trans.next, struct tree_buffer, dirty);
b = list_entry(root->trans.next, struct btrfs_buffer, dirty);
list_del_init(&b->dirty);
wret = write_tree_block(root, b);
if (wret)
ret = wret;
tree_block_release(root, b);
btrfs_block_release(root, b);
}
return ret;
}
int commit_transaction(struct ctree_root *root, struct ctree_super_block *s)
int btrfs_commit_transaction(struct btrfs_root *root,
struct btrfs_super_block *s)
{
int ret = 0;
@ -163,20 +164,20 @@ int commit_transaction(struct ctree_root *root, struct ctree_super_block *s)
ret = __commit_transaction(root->extent_root);
BUG_ON(ret);
if (root->commit_root != root->node) {
struct tree_buffer *snap = root->commit_root;
struct btrfs_buffer *snap = root->commit_root;
root->commit_root = root->node;
root->node->count++;
ret = btrfs_drop_snapshot(root, snap);
BUG_ON(ret);
// tree_block_release(root, snap);
// btrfs_block_release(root, snap);
}
write_ctree_super(root, s);
btrfs_finish_extent_commit(root);
return ret;
}
static int __setup_root(struct ctree_root *root, struct ctree_root *extent_root,
struct ctree_root_info *info, int fp)
static int __setup_root(struct btrfs_root *root, struct btrfs_root *extent_root,
struct btrfs_root_info *info, int fp)
{
INIT_LIST_HEAD(&root->trans);
INIT_LIST_HEAD(&root->cache);
@ -191,10 +192,10 @@ static int __setup_root(struct ctree_root *root, struct ctree_root *extent_root,
return 0;
}
struct ctree_root *open_ctree(char *filename, struct ctree_super_block *super)
struct btrfs_root *open_ctree(char *filename, struct btrfs_super_block *super)
{
struct ctree_root *root = malloc(sizeof(struct ctree_root));
struct ctree_root *extent_root = malloc(sizeof(struct ctree_root));
struct btrfs_root *root = malloc(sizeof(struct btrfs_root));
struct btrfs_root *extent_root = malloc(sizeof(struct btrfs_root));
int fp;
int ret;
@ -207,16 +208,16 @@ struct ctree_root *open_ctree(char *filename, struct ctree_super_block *super)
INIT_RADIX_TREE(&root->pinned_radix, GFP_KERNEL);
INIT_RADIX_TREE(&extent_root->pinned_radix, GFP_KERNEL);
INIT_RADIX_TREE(&extent_root->cache_radix, GFP_KERNEL);
ret = pread(fp, super, sizeof(struct ctree_super_block),
CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
ret = pread(fp, super, sizeof(struct btrfs_super_block),
BTRFS_SUPER_INFO_OFFSET(BTRFS_BLOCKSIZE));
if (ret == 0 || super->root_info.tree_root == 0) {
printf("making new FS!\n");
ret = mkfs(fp);
if (ret)
return NULL;
ret = pread(fp, super, sizeof(struct ctree_super_block),
CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
if (ret != sizeof(struct ctree_super_block))
ret = pread(fp, super, sizeof(struct btrfs_super_block),
BTRFS_SUPER_INFO_OFFSET(BTRFS_BLOCKSIZE));
if (ret != sizeof(struct btrfs_super_block))
return NULL;
}
BUG_ON(ret < 0);
@ -227,18 +228,19 @@ struct ctree_root *open_ctree(char *filename, struct ctree_super_block *super)
return root;
}
static int __update_root(struct ctree_root *root, struct ctree_root_info *info)
static int __update_root(struct btrfs_root *root, struct btrfs_root_info *info)
{
info->tree_root = root->node->blocknr;
return 0;
}
int write_ctree_super(struct ctree_root *root, struct ctree_super_block *s)
int write_ctree_super(struct btrfs_root *root, struct btrfs_super_block *s)
{
int ret;
__update_root(root, &s->root_info);
__update_root(root->extent_root, &s->extent_info);
ret = pwrite(root->fp, s, sizeof(*s), CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
ret = pwrite(root->fp, s, sizeof(*s),
BTRFS_SUPER_INFO_OFFSET(BTRFS_BLOCKSIZE));
if (ret != sizeof(*s)) {
fprintf(stderr, "failed to write new super block err %d\n", ret);
return ret;
@ -246,19 +248,19 @@ int write_ctree_super(struct ctree_root *root, struct ctree_super_block *s)
return 0;
}
static int drop_cache(struct ctree_root *root)
static int drop_cache(struct btrfs_root *root)
{
while(!list_empty(&root->cache)) {
struct tree_buffer *b = list_entry(root->cache.next,
struct tree_buffer, cache);
struct btrfs_buffer *b = list_entry(root->cache.next,
struct btrfs_buffer, cache);
list_del_init(&b->cache);
tree_block_release(root, b);
btrfs_block_release(root, b);
}
return 0;
}
int close_ctree(struct ctree_root *root, struct ctree_super_block *s)
int close_ctree(struct btrfs_root *root, struct btrfs_super_block *s)
{
commit_transaction(root, s);
btrfs_commit_transaction(root, s);
__commit_transaction(root->extent_root);
write_ctree_super(root, s);
drop_cache(root->extent_root);
@ -268,16 +270,16 @@ int close_ctree(struct ctree_root *root, struct ctree_super_block *s)
close(root->fp);
if (root->node)
tree_block_release(root, root->node);
btrfs_block_release(root, root->node);
if (root->extent_root->node)
tree_block_release(root->extent_root, root->extent_root->node);
tree_block_release(root, root->commit_root);
btrfs_block_release(root->extent_root, root->extent_root->node);
btrfs_block_release(root, root->commit_root);
free(root);
printf("on close %d blocks are allocated\n", allocated_blocks);
return 0;
}
void tree_block_release(struct ctree_root *root, struct tree_buffer *buf)
void btrfs_block_release(struct btrfs_root *root, struct btrfs_buffer *buf)
{
buf->count--;
if (buf->count < 0)

29
fs/btrfs/disk-io.h
View File

@ -2,29 +2,30 @@
#define __DISKIO__
#include "list.h"
struct tree_buffer {
struct btrfs_buffer {
u64 blocknr;
int count;
union {
struct node node;
struct leaf leaf;
struct btrfs_node node;
struct btrfs_leaf leaf;
};
struct list_head dirty;
struct list_head cache;
};
struct tree_buffer *read_tree_block(struct ctree_root *root, u64 blocknr);
struct tree_buffer *find_tree_block(struct ctree_root *root, u64 blocknr);
int write_tree_block(struct ctree_root *root, struct tree_buffer *buf);
int dirty_tree_block(struct ctree_root *root, struct tree_buffer *buf);
int clean_tree_block(struct ctree_root *root, struct tree_buffer *buf);
int commit_transaction(struct ctree_root *root, struct ctree_super_block *s);
struct ctree_root *open_ctree(char *filename, struct ctree_super_block *s);
int close_ctree(struct ctree_root *root, struct ctree_super_block *s);
void tree_block_release(struct ctree_root *root, struct tree_buffer *buf);
int write_ctree_super(struct ctree_root *root, struct ctree_super_block *s);
struct btrfs_buffer *read_tree_block(struct btrfs_root *root, u64 blocknr);
struct btrfs_buffer *find_tree_block(struct btrfs_root *root, u64 blocknr);
int write_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf);
int dirty_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf);
int clean_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf);
int btrfs_commit_transaction(struct btrfs_root *root,
struct btrfs_super_block *s);
struct btrfs_root *open_ctree(char *filename, struct btrfs_super_block *s);
int close_ctree(struct btrfs_root *root, struct btrfs_super_block *s);
void btrfs_block_release(struct btrfs_root *root, struct btrfs_buffer *buf);
int write_ctree_super(struct btrfs_root *root, struct btrfs_super_block *s);
int mkfs(int fd);
#define CTREE_SUPER_INFO_OFFSET(bs) (16 * (bs))
#define BTRFS_SUPER_INFO_OFFSET(bs) (16 * (bs))
#endif

147
fs/btrfs/extent-tree.c
View File

@ -6,11 +6,11 @@
#include "disk-io.h"
#include "print-tree.h"
static int find_free_extent(struct ctree_root *orig_root, u64 num_blocks,
static int find_free_extent(struct btrfs_root *orig_root, u64 num_blocks,
u64 search_start, u64 search_end,
struct btrfs_key *ins);
static int finish_current_insert(struct ctree_root *extent_root);
static int run_pending(struct ctree_root *extent_root);
static int finish_current_insert(struct btrfs_root *extent_root);
static int run_pending(struct btrfs_root *extent_root);
/*
* pending extents are blocks that we're trying to allocate in the extent
@ -21,62 +21,63 @@ static int run_pending(struct ctree_root *extent_root);
*/
#define CTREE_EXTENT_PENDING_DEL 0
static int inc_block_ref(struct ctree_root *root, u64 blocknr)
static int inc_block_ref(struct btrfs_root *root, u64 blocknr)
{
struct ctree_path path;
struct btrfs_path path;
int ret;
struct btrfs_key key;
struct leaf *l;
struct extent_item *item;
struct btrfs_leaf *l;
struct btrfs_extent_item *item;
struct btrfs_key ins;
u32 refs;
find_free_extent(root->extent_root, 0, 0, (u64)-1, &ins);
init_path(&path);
btrfs_init_path(&path);
key.objectid = blocknr;
key.flags = 0;
key.offset = 1;
ret = search_slot(root->extent_root, &key, &path, 0, 1);
ret = btrfs_search_slot(root->extent_root, &key, &path, 0, 1);
if (ret != 0)
BUG();
BUG_ON(ret != 0);
l = &path.nodes[0]->leaf;
item = (struct extent_item *)(l->data + btrfs_item_offset(l->items +
path.slots[0]));
item = (struct btrfs_extent_item *)(l->data +
btrfs_item_offset(l->items +
path.slots[0]));
refs = btrfs_extent_refs(item);
btrfs_set_extent_refs(item, refs + 1);
BUG_ON(list_empty(&path.nodes[0]->dirty));
release_path(root->extent_root, &path);
btrfs_release_path(root->extent_root, &path);
finish_current_insert(root->extent_root);
run_pending(root->extent_root);
return 0;
}
static int lookup_block_ref(struct ctree_root *root, u64 blocknr, u32 *refs)
static int lookup_block_ref(struct btrfs_root *root, u64 blocknr, u32 *refs)
{
struct ctree_path path;
struct btrfs_path path;
int ret;
struct btrfs_key key;
struct leaf *l;
struct extent_item *item;
init_path(&path);
struct btrfs_leaf *l;
struct btrfs_extent_item *item;
btrfs_init_path(&path);
key.objectid = blocknr;
key.flags = 0;
key.offset = 1;
ret = search_slot(root->extent_root, &key, &path, 0, 0);
ret = btrfs_search_slot(root->extent_root, &key, &path, 0, 0);
if (ret != 0)
BUG();
l = &path.nodes[0]->leaf;
item = (struct extent_item *)(l->data +
item = (struct btrfs_extent_item *)(l->data +
btrfs_item_offset(l->items +
path.slots[0]));
*refs = btrfs_extent_refs(item);
release_path(root->extent_root, &path);
btrfs_release_path(root->extent_root, &path);
return 0;
}
int btrfs_inc_ref(struct ctree_root *root, struct tree_buffer *buf)
int btrfs_inc_ref(struct btrfs_root *root, struct btrfs_buffer *buf)
{
u64 blocknr;
int i;
@ -93,9 +94,9 @@ int btrfs_inc_ref(struct ctree_root *root, struct tree_buffer *buf)
return 0;
}
int btrfs_finish_extent_commit(struct ctree_root *root)
int btrfs_finish_extent_commit(struct btrfs_root *root)
{
struct ctree_root *extent_root = root->extent_root;
struct btrfs_root *extent_root = root->extent_root;
unsigned long gang[8];
int ret;
int i;
@ -115,10 +116,10 @@ int btrfs_finish_extent_commit(struct ctree_root *root)
return 0;
}
static int finish_current_insert(struct ctree_root *extent_root)
static int finish_current_insert(struct btrfs_root *extent_root)
{
struct btrfs_key ins;
struct extent_item extent_item;
struct btrfs_extent_item extent_item;
int i;
int ret;
@ -130,7 +131,7 @@ static int finish_current_insert(struct ctree_root *extent_root)
for (i = 0; i < extent_root->current_insert.flags; i++) {
ins.objectid = extent_root->current_insert.objectid + i;
ret = insert_item(extent_root, &ins, &extent_item,
ret = btrfs_insert_item(extent_root, &ins, &extent_item,
sizeof(extent_item));
BUG_ON(ret);
}
@ -141,14 +142,14 @@ static int finish_current_insert(struct ctree_root *extent_root)
/*
* remove an extent from the root, returns 0 on success
*/
int __free_extent(struct ctree_root *root, u64 blocknr, u64 num_blocks)
static int __free_extent(struct btrfs_root *root, u64 blocknr, u64 num_blocks)
{
struct ctree_path path;
struct btrfs_path path;
struct btrfs_key key;
struct ctree_root *extent_root = root->extent_root;
struct btrfs_root *extent_root = root->extent_root;
int ret;
struct btrfs_item *item;
struct extent_item *ei;
struct btrfs_extent_item *ei;
struct btrfs_key ins;
u32 refs;
@ -157,16 +158,16 @@ int __free_extent(struct ctree_root *root, u64 blocknr, u64 num_blocks)
key.offset = num_blocks;
find_free_extent(root, 0, 0, (u64)-1, &ins);
init_path(&path);
ret = search_slot(extent_root, &key, &path, -1, 1);
btrfs_init_path(&path);
ret = btrfs_search_slot(extent_root, &key, &path, -1, 1);
if (ret) {
printf("failed to find %Lu\n", key.objectid);
print_tree(extent_root, extent_root->node);
btrfs_print_tree(extent_root, extent_root->node);
printf("failed to find %Lu\n", key.objectid);
BUG();
}
item = path.nodes[0]->leaf.items + path.slots[0];
ei = (struct extent_item *)(path.nodes[0]->leaf.data +
ei = (struct btrfs_extent_item *)(path.nodes[0]->leaf.data +
btrfs_item_offset(item));
BUG_ON(ei->refs == 0);
refs = btrfs_extent_refs(ei) - 1;
@ -180,14 +181,14 @@ int __free_extent(struct ctree_root *root, u64 blocknr, u64 num_blocks)
BUG_ON(err);
radix_tree_preload_end();
}
ret = del_item(extent_root, &path);
ret = btrfs_del_item(extent_root, &path);
if (root != extent_root &&
extent_root->last_insert.objectid < blocknr)
extent_root->last_insert.objectid = blocknr;
if (ret)
BUG();
}
release_path(extent_root, &path);
btrfs_release_path(extent_root, &path);
finish_current_insert(extent_root);
return ret;
}
@ -196,10 +197,10 @@ int __free_extent(struct ctree_root *root, u64 blocknr, u64 num_blocks)
* find all the blocks marked as pending in the radix tree and remove
* them from the extent map
*/
static int del_pending_extents(struct ctree_root *extent_root)
static int del_pending_extents(struct btrfs_root *extent_root)
{
int ret;
struct tree_buffer *gang[4];
struct btrfs_buffer *gang[4];
int i;
while(1) {
@ -214,13 +215,13 @@ static int del_pending_extents(struct ctree_root *extent_root)
radix_tree_tag_clear(&extent_root->cache_radix,
gang[i]->blocknr,
CTREE_EXTENT_PENDING_DEL);
tree_block_release(extent_root, gang[i]);
btrfs_block_release(extent_root, gang[i]);
}
}
return 0;
}
static int run_pending(struct ctree_root *extent_root)
static int run_pending(struct btrfs_root *extent_root)
{
while(radix_tree_tagged(&extent_root->cache_radix,
CTREE_EXTENT_PENDING_DEL))
@ -232,11 +233,11 @@ static int run_pending(struct ctree_root *extent_root)
/*
* remove an extent from the root, returns 0 on success
*/
int free_extent(struct ctree_root *root, u64 blocknr, u64 num_blocks)
int btrfs_free_extent(struct btrfs_root *root, u64 blocknr, u64 num_blocks)
{
struct btrfs_key key;
struct ctree_root *extent_root = root->extent_root;
struct tree_buffer *t;
struct btrfs_root *extent_root = root->extent_root;
struct btrfs_buffer *t;
int pending_ret;
int ret;
@ -262,11 +263,11 @@ int free_extent(struct ctree_root *root, u64 blocknr, u64 num_blocks)
* ins->offset == number of blocks
* Any available blocks before search_start are skipped.
*/
static int find_free_extent(struct ctree_root *orig_root, u64 num_blocks,
static int find_free_extent(struct btrfs_root *orig_root, u64 num_blocks,
u64 search_start, u64 search_end,
struct btrfs_key *ins)
{
struct ctree_path path;
struct btrfs_path path;
struct btrfs_key key;
int ret;
u64 hole_size = 0;
@ -274,20 +275,20 @@ static int find_free_extent(struct ctree_root *orig_root, u64 num_blocks,
u64 last_block;
u64 test_block;
int start_found;
struct leaf *l;
struct ctree_root * root = orig_root->extent_root;
struct btrfs_leaf *l;
struct btrfs_root * root = orig_root->extent_root;
int total_needed = num_blocks;
total_needed += (btrfs_header_level(&root->node->node.header) + 1) * 3;
if (root->last_insert.objectid > search_start)
search_start = root->last_insert.objectid;
check_failed:
init_path(&path);
btrfs_init_path(&path);
ins->objectid = search_start;
ins->offset = 0;
ins->flags = 0;
start_found = 0;
ret = search_slot(root, ins, &path, 0, 0);
ret = btrfs_search_slot(root, ins, &path, 0, 0);
if (ret < 0)
goto error;
@ -298,7 +299,7 @@ check_failed:
l = &path.nodes[0]->leaf;
slot = path.slots[0];
if (slot >= btrfs_header_nritems(&l->header)) {
ret = next_leaf(root, &path);
ret = btrfs_next_leaf(root, &path);
if (ret == 0)
continue;
if (ret < 0)
@ -336,7 +337,7 @@ check_pending:
/* we have to make sure we didn't find an extent that has already
* been allocated by the map tree or the original allocation
*/
release_path(root, &path);
btrfs_release_path(root, &path);
BUG_ON(ins->objectid < search_start);
for (test_block = ins->objectid;
test_block < ins->objectid + total_needed; test_block++) {
@ -353,7 +354,7 @@ check_pending:
ins->offset = num_blocks;
return 0;
error:
release_path(root, &path);
btrfs_release_path(root, &path);
return ret;
}
@ -364,13 +365,13 @@ error:
*
* returns 0 if everything worked, non-zero otherwise.
*/
int alloc_extent(struct ctree_root *root, u64 num_blocks, u64 search_start,
int alloc_extent(struct btrfs_root *root, u64 num_blocks, u64 search_start,
u64 search_end, u64 owner, struct btrfs_key *ins)
{
int ret;
int pending_ret;
struct ctree_root *extent_root = root->extent_root;
struct extent_item extent_item;
struct btrfs_root *extent_root = root->extent_root;
struct btrfs_extent_item extent_item;
btrfs_set_extent_refs(&extent_item, 1);
btrfs_set_extent_owner(&extent_item, owner);
@ -390,7 +391,7 @@ int alloc_extent(struct ctree_root *root, u64 num_blocks, u64 search_start,
if (ret)
return ret;
ret = insert_item(extent_root, ins, &extent_item,
ret = btrfs_insert_item(extent_root, ins, &extent_item,
sizeof(extent_item));
finish_current_insert(extent_root);
@ -406,11 +407,11 @@ int alloc_extent(struct ctree_root *root, u64 num_blocks, u64 search_start,
* helper function to allocate a block for a given tree
* returns the tree buffer or NULL.
*/
struct tree_buffer *alloc_free_block(struct ctree_root *root)
struct btrfs_buffer *btrfs_alloc_free_block(struct btrfs_root *root)
{
struct btrfs_key ins;
int ret;
struct tree_buffer *buf;
struct btrfs_buffer *buf;
ret = alloc_extent(root, 1, 0, (unsigned long)-1,
btrfs_header_parentid(&root->node->node.header),
@ -424,10 +425,10 @@ struct tree_buffer *alloc_free_block(struct ctree_root *root)
return buf;
}
int walk_down_tree(struct ctree_root *root, struct ctree_path *path, int *level)
int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path, int *level)
{
struct tree_buffer *next;
struct tree_buffer *cur;
struct btrfs_buffer *next;
struct btrfs_buffer *cur;
u64 blocknr;
int ret;
u32 refs;
@ -445,33 +446,33 @@ int walk_down_tree(struct ctree_root *root, struct ctree_path *path, int *level)
ret = lookup_block_ref(root, blocknr, &refs);
if (refs != 1 || *level == 1) {
path->slots[*level]++;
ret = free_extent(root, blocknr, 1);
ret = btrfs_free_extent(root, blocknr, 1);
BUG_ON(ret);
continue;
}
BUG_ON(ret);
next = read_tree_block(root, blocknr);
if (path->nodes[*level-1])
tree_block_release(root, path->nodes[*level-1]);
btrfs_block_release(root, path->nodes[*level-1]);
path->nodes[*level-1] = next;
*level = btrfs_header_level(&next->node.header);
path->slots[*level] = 0;
}
out:
ret = free_extent(root, path->nodes[*level]->blocknr, 1);
tree_block_release(root, path->nodes[*level]);
ret = btrfs_free_extent(root, path->nodes[*level]->blocknr, 1);
btrfs_block_release(root, path->nodes[*level]);
path->nodes[*level] = NULL;
*level += 1;
BUG_ON(ret);
return 0;
}
int walk_up_tree(struct ctree_root *root, struct ctree_path *path, int *level)
int walk_up_tree(struct btrfs_root *root, struct btrfs_path *path, int *level)
{
int i;
int slot;
int ret;
for(i = *level; i < MAX_LEVEL - 1 && path->nodes[i]; i++) {
for(i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
slot = path->slots[i];
if (slot <
btrfs_header_nritems(&path->nodes[i]->node.header)- 1) {
@ -479,9 +480,9 @@ int walk_up_tree(struct ctree_root *root, struct ctree_path *path, int *level)
*level = i;
return 0;
} else {
ret = free_extent(root,
ret = btrfs_free_extent(root,
path->nodes[*level]->blocknr, 1);
tree_block_release(root, path->nodes[*level]);
btrfs_block_release(root, path->nodes[*level]);
path->nodes[*level] = NULL;
*level = i + 1;
BUG_ON(ret);
@ -490,15 +491,15 @@ int walk_up_tree(struct ctree_root *root, struct ctree_path *path, int *level)
return 1;
}
int btrfs_drop_snapshot(struct ctree_root *root, struct tree_buffer *snap)
int btrfs_drop_snapshot(struct btrfs_root *root, struct btrfs_buffer *snap)
{
int ret;
int level;
struct ctree_path path;
struct btrfs_path path;
int i;
int orig_level;
init_path(&path);
btrfs_init_path(&path);
level = btrfs_header_level(&snap->node.header);
orig_level = level;
@ -514,7 +515,7 @@ int btrfs_drop_snapshot(struct ctree_root *root, struct tree_buffer *snap)
}
for (i = 0; i <= orig_level; i++) {
if (path.nodes[i]) {
tree_block_release(root, path.nodes[i]);
btrfs_block_release(root, path.nodes[i]);
}
}

26
fs/btrfs/mkfs.c
View File

@ -12,10 +12,10 @@
int mkfs(int fd)
{
struct ctree_root_info info[2];
struct leaf empty_leaf;
struct btrfs_root_info info[2];
struct btrfs_leaf empty_leaf;
struct btrfs_item item;
struct extent_item extent_item;
struct btrfs_extent_item extent_item;
int ret;
/* setup the super block area */
@ -28,7 +28,7 @@ int mkfs(int fd)
info[1].objectid = 2;
info[1].tree_root = 18;
ret = pwrite(fd, info, sizeof(info),
CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
BTRFS_SUPER_INFO_OFFSET(BTRFS_BLOCKSIZE));
if (ret != sizeof(info))
return -1;
@ -36,7 +36,7 @@ int mkfs(int fd)
memset(&empty_leaf, 0, sizeof(empty_leaf));
btrfs_set_header_parentid(&empty_leaf.header, 1);
btrfs_set_header_blocknr(&empty_leaf.header, 17);
ret = pwrite(fd, &empty_leaf, sizeof(empty_leaf), 17 * CTREE_BLOCKSIZE);
ret = pwrite(fd, &empty_leaf, sizeof(empty_leaf), 17 * BTRFS_BLOCKSIZE);
if (ret != sizeof(empty_leaf))
return -1;
@ -48,9 +48,9 @@ int mkfs(int fd)
btrfs_set_key_objectid(&item.key, 0);
btrfs_set_key_offset(&item.key, 17);
btrfs_set_key_flags(&item.key, 0);
btrfs_set_item_offset(&item,
LEAF_DATA_SIZE - sizeof(struct extent_item));
btrfs_set_item_size(&item, sizeof(struct extent_item));
btrfs_set_item_offset(&item, LEAF_DATA_SIZE -
sizeof(struct btrfs_extent_item));
btrfs_set_item_size(&item, sizeof(struct btrfs_extent_item));
btrfs_set_extent_refs(&extent_item, 1);
btrfs_set_extent_owner(&extent_item, 0);
memcpy(empty_leaf.items, &item, sizeof(item));
@ -60,8 +60,8 @@ int mkfs(int fd)
/* item2, give block 17 to the root */
btrfs_set_key_objectid(&item.key, 17);
btrfs_set_key_offset(&item.key, 1);
btrfs_set_item_offset(&item,
LEAF_DATA_SIZE - sizeof(struct extent_item) * 2);
btrfs_set_item_offset(&item, LEAF_DATA_SIZE -
sizeof(struct btrfs_extent_item) * 2);
btrfs_set_extent_owner(&extent_item, 1);
memcpy(empty_leaf.items + 1, &item, sizeof(item));
memcpy(empty_leaf.data + btrfs_item_offset(&item), &extent_item,
@ -70,13 +70,13 @@ int mkfs(int fd)
/* item3, give block 18 for the extent root */
btrfs_set_key_objectid(&item.key, 18);
btrfs_set_key_offset(&item.key, 1);
btrfs_set_item_offset(&item,
LEAF_DATA_SIZE - sizeof(struct extent_item) * 3);
btrfs_set_item_offset(&item, LEAF_DATA_SIZE -
sizeof(struct btrfs_extent_item) * 3);
btrfs_set_extent_owner(&extent_item, 2);
memcpy(empty_leaf.items + 2, &item, sizeof(item));
memcpy(empty_leaf.data + btrfs_item_offset(&item), &extent_item,
btrfs_item_size(&item));
ret = pwrite(fd, &empty_leaf, sizeof(empty_leaf), 18 * CTREE_BLOCKSIZE);
ret = pwrite(fd, &empty_leaf, sizeof(empty_leaf), 18 * BTRFS_BLOCKSIZE);
if (ret != sizeof(empty_leaf))
return -1;
return 0;

23
fs/btrfs/print-tree.c
View File

@ -5,14 +5,14 @@
#include "ctree.h"
#include "disk-io.h"
void print_leaf(struct leaf *l)
void btrfs_print_leaf(struct btrfs_leaf *l)
{
int i;
u32 nr = btrfs_header_nritems(&l->header);
struct btrfs_item *item;
struct extent_item *ei;
struct btrfs_extent_item *ei;
printf("leaf %Lu total ptrs %d free space %d\n",
btrfs_header_blocknr(&l->header), nr, leaf_free_space(l));
btrfs_header_blocknr(&l->header), nr, btrfs_leaf_free_space(l));
fflush(stdout);
for (i = 0 ; i < nr ; i++) {
item = l->items + i;
@ -26,24 +26,25 @@ void print_leaf(struct leaf *l)
fflush(stdout);
printf("\t\titem data %.*s\n", btrfs_item_size(item),
l->data + btrfs_item_offset(item));
ei = (struct extent_item *)(l->data + btrfs_item_offset(item));
ei = (struct btrfs_extent_item *)(l->data +
btrfs_item_offset(item));
printf("\t\textent data refs %u owner %Lu\n", ei->refs,
ei->owner);
fflush(stdout);
}
}
void print_tree(struct ctree_root *root, struct tree_buffer *t)
void btrfs_print_tree(struct btrfs_root *root, struct btrfs_buffer *t)
{
int i;
u32 nr;
struct node *c;
struct btrfs_node *c;
if (!t)
return;
c = &t->node;
nr = btrfs_header_nritems(&c->header);
if (btrfs_is_leaf(c)) {
print_leaf((struct leaf *)c);
btrfs_print_leaf((struct btrfs_leaf *)c);
return;
}
printf("node %Lu level %d total ptrs %d free spc %u\n", t->blocknr,
@ -58,17 +59,17 @@ void print_tree(struct ctree_root *root, struct tree_buffer *t)
fflush(stdout);
}
for (i = 0; i < nr; i++) {
struct tree_buffer *next_buf = read_tree_block(root,
struct btrfs_buffer *next_buf = read_tree_block(root,
btrfs_node_blockptr(c, i));
struct node *next = &next_buf->node;
struct btrfs_node *next = &next_buf->node;
if (btrfs_is_leaf(next) &&
btrfs_header_level(&c->header) != 1)
BUG();
if (btrfs_header_level(&next->header) !=
btrfs_header_level(&c->header) - 1)
BUG();
print_tree(root, next_buf);
tree_block_release(root, next_buf);
btrfs_print_tree(root, next_buf);
btrfs_block_release(root, next_buf);
}
}

4
fs/btrfs/print-tree.h
View File

@ -1,3 +1,3 @@
void print_leaf(struct leaf *l);
void print_tree(struct ctree_root *root, struct tree_buffer *t);
void btrfs_print_leaf(struct btrfs_leaf *l);
void btrfs_print_tree(struct btrfs_root *root, struct btrfs_buffer *t);

54
fs/btrfs/quick-test.c
View File

@ -22,9 +22,9 @@ int main(int ac, char **av) {
int run_size = 100000;
int max_key = 100000000;
int tree_size = 0;
struct ctree_path path;
struct ctree_super_block super;
struct ctree_root *root;
struct btrfs_path path;
struct btrfs_super_block super;
struct btrfs_root *root;
radix_tree_init();
@ -40,12 +40,12 @@ int main(int ac, char **av) {
ins.objectid = num;
ins.offset = 0;
ins.flags = 0;
ret = insert_item(root, &ins, buf, strlen(buf));
ret = btrfs_insert_item(root, &ins, buf, strlen(buf));
if (!ret)
tree_size++;
free(buf);
if (i == run_size - 5) {
commit_transaction(root, &super);
btrfs_commit_transaction(root, &super);
}
}
@ -57,16 +57,16 @@ int main(int ac, char **av) {
for (i = 0; i < run_size; i++) {
num = next_key(i, max_key);
ins.objectid = num;
init_path(&path);
btrfs_init_path(&path);
if (i % 10000 == 0)
fprintf(stderr, "search %d:%d\n", num, i);
ret = search_slot(root, &ins, &path, 0, 0);
ret = btrfs_search_slot(root, &ins, &path, 0, 0);
if (ret) {
print_tree(root, root->node);
btrfs_print_tree(root, root->node);
printf("unable to find %d\n", num);
exit(1);
}
release_path(root, &path);
btrfs_release_path(root, &path);
}
close_ctree(root, &super);
root = open_ctree("dbfile", &super);
@ -81,17 +81,17 @@ int main(int ac, char **av) {
for (i = 0 ; i < run_size/4; i++) {
num = next_key(i, max_key);
ins.objectid = num;
init_path(&path);
ret = search_slot(root, &ins, &path, -1, 1);
btrfs_init_path(&path);
ret = btrfs_search_slot(root, &ins, &path, -1, 1);
if (!ret) {
if (i % 10000 == 0)
fprintf(stderr, "del %d:%d\n", num, i);
ret = del_item(root, &path);
ret = btrfs_del_item(root, &path);
if (ret != 0)
BUG();
tree_size--;
}
release_path(root, &path);
btrfs_release_path(root, &path);
}
close_ctree(root, &super);
root = open_ctree("dbfile", &super);
@ -103,7 +103,7 @@ int main(int ac, char **av) {
ins.objectid = num;
if (i % 10000 == 0)
fprintf(stderr, "insert %d:%d\n", num, i);
ret = insert_item(root, &ins, buf, strlen(buf));
ret = btrfs_insert_item(root, &ins, buf, strlen(buf));
if (!ret)
tree_size++;
free(buf);
@ -115,25 +115,25 @@ int main(int ac, char **av) {
for (i = 0; i < run_size; i++) {
num = next_key(i, max_key);
ins.objectid = num;
init_path(&path);
btrfs_init_path(&path);
if (i % 10000 == 0)
fprintf(stderr, "search %d:%d\n", num, i);
ret = search_slot(root, &ins, &path, 0, 0);
ret = btrfs_search_slot(root, &ins, &path, 0, 0);
if (ret) {
print_tree(root, root->node);
btrfs_print_tree(root, root->node);
printf("unable to find %d\n", num);
exit(1);
}
release_path(root, &path);
btrfs_release_path(root, &path);
}
printf("starting big long delete run\n");
while(root->node &&
btrfs_header_nritems(&root->node->node.header) > 0) {
struct leaf *leaf;
struct btrfs_leaf *leaf;
int slot;
ins.objectid = (u64)-1;
init_path(&path);
ret = search_slot(root, &ins, &path, -1, 1);
btrfs_init_path(&path);
ret = btrfs_search_slot(root, &ins, &path, -1, 1);
if (ret == 0)
BUG();
@ -149,26 +149,26 @@ int main(int ac, char **av) {
btrfs_disk_key_to_cpu(&last, &leaf->items[slot].key);
if (tree_size % 10000 == 0)
printf("big del %d:%d\n", tree_size, i);
ret = del_item(root, &path);
ret = btrfs_del_item(root, &path);
if (ret != 0) {
printf("del_item returned %d\n", ret);
BUG();
}
tree_size--;
}
release_path(root, &path);
btrfs_release_path(root, &path);
}
/*
printf("previous tree:\n");
print_tree(root, root->commit_root);
btrfs_print_tree(root, root->commit_root);
printf("map before commit\n");
print_tree(root->extent_root, root->extent_root->node);
btrfs_print_tree(root->extent_root, root->extent_root->node);
*/
commit_transaction(root, &super);
btrfs_commit_transaction(root, &super);
printf("tree size is now %d\n", tree_size);
printf("root %p commit root %p\n", root->node, root->commit_root);
printf("map tree\n");
print_tree(root->extent_root, root->extent_root->node);
btrfs_print_tree(root->extent_root, root->extent_root->node);
close_ctree(root, &super);
return 0;
}

92
fs/btrfs/random-test.c
View File

@ -8,7 +8,7 @@
#include "print-tree.h"
int keep_running = 1;
struct ctree_super_block super;
struct btrfs_super_block super;
static int setup_key(struct radix_tree_root *root, struct btrfs_key *key,
int exists)
@ -36,17 +36,17 @@ again:
return 0;
}
static int ins_one(struct ctree_root *root, struct radix_tree_root *radix)
static int ins_one(struct btrfs_root *root, struct radix_tree_root *radix)
{
struct ctree_path path;
struct btrfs_path path;
struct btrfs_key key;
int ret;
char buf[128];
unsigned long oid;
init_path(&path);
btrfs_init_path(&path);
ret = setup_key(radix, &key, 0);
sprintf(buf, "str-%Lu\n", key.objectid);
ret = insert_item(root, &key, buf, strlen(buf));
ret = btrfs_insert_item(root, &key, buf, strlen(buf));
if (ret)
goto error;
oid = (unsigned long)key.objectid;
@ -61,18 +61,18 @@ error:
return -1;
}
static int insert_dup(struct ctree_root *root, struct radix_tree_root *radix)
static int insert_dup(struct btrfs_root *root, struct radix_tree_root *radix)
{
struct ctree_path path;
struct btrfs_path path;
struct btrfs_key key;
int ret;
char buf[128];
init_path(&path);
btrfs_init_path(&path);
ret = setup_key(radix, &key, 1);
if (ret < 0)
return 0;
sprintf(buf, "str-%Lu\n", key.objectid);
ret = insert_item(root, &key, buf, strlen(buf));
ret = btrfs_insert_item(root, &key, buf, strlen(buf));
if (ret != -EEXIST) {
printf("insert on %Lu gave us %d\n", key.objectid, ret);
return 1;
@ -80,21 +80,21 @@ static int insert_dup(struct ctree_root *root, struct radix_tree_root *radix)
return 0;
}
static int del_one(struct ctree_root *root, struct radix_tree_root *radix)
static int del_one(struct btrfs_root *root, struct radix_tree_root *radix)
{
struct ctree_path path;
struct btrfs_path path;
struct btrfs_key key;
int ret;
unsigned long *ptr;
init_path(&path);
btrfs_init_path(&path);
ret = setup_key(radix, &key, 1);
if (ret < 0)
return 0;
ret = search_slot(root, &key, &path, -1, 1);
ret = btrfs_search_slot(root, &key, &path, -1, 1);
if (ret)
goto error;
ret = del_item(root, &path);
release_path(root, &path);
ret = btrfs_del_item(root, &path);
btrfs_release_path(root, &path);
if (ret != 0)
goto error;
ptr = radix_tree_delete(radix, key.objectid);
@ -106,17 +106,17 @@ error:
return -1;
}
static int lookup_item(struct ctree_root *root, struct radix_tree_root *radix)
static int lookup_item(struct btrfs_root *root, struct radix_tree_root *radix)
{
struct ctree_path path;
struct btrfs_path path;
struct btrfs_key key;
int ret;
init_path(&path);
btrfs_init_path(&path);
ret = setup_key(radix, &key, 1);
if (ret < 0)
return 0;
ret = search_slot(root, &key, &path, 0, 1);
release_path(root, &path);
ret = btrfs_search_slot(root, &key, &path, 0, 1);
btrfs_release_path(root, &path);
if (ret)
goto error;
return 0;
@ -125,17 +125,17 @@ error:
return -1;
}
static int lookup_enoent(struct ctree_root *root, struct radix_tree_root *radix)
static int lookup_enoent(struct btrfs_root *root, struct radix_tree_root *radix)
{
struct ctree_path path;
struct btrfs_path path;
struct btrfs_key key;
int ret;
init_path(&path);
btrfs_init_path(&path);
ret = setup_key(radix, &key, 0);
if (ret < 0)
return ret;
ret = search_slot(root, &key, &path, 0, 0);
release_path(root, &path);
ret = btrfs_search_slot(root, &key, &path, 0, 0);
btrfs_release_path(root, &path);
if (ret <= 0)
goto error;
return 0;
@ -144,10 +144,10 @@ error:
return -1;
}
static int empty_tree(struct ctree_root *root, struct radix_tree_root *radix,
static int empty_tree(struct btrfs_root *root, struct radix_tree_root *radix,
int nr)
{
struct ctree_path path;
struct btrfs_path path;
struct btrfs_key key;
unsigned long found = 0;
int ret;
@ -159,22 +159,22 @@ static int empty_tree(struct ctree_root *root, struct radix_tree_root *radix,
key.flags = 0;
key.objectid = (unsigned long)-1;
while(nr-- >= 0) {
init_path(&path);
ret = search_slot(root, &key, &path, -1, 1);
btrfs_init_path(&path);
ret = btrfs_search_slot(root, &key, &path, -1, 1);
if (ret < 0) {
release_path(root, &path);
btrfs_release_path(root, &path);
return ret;
}
if (ret != 0) {
if (path.slots[0] == 0) {
release_path(root, &path);
btrfs_release_path(root, &path);
break;
}
path.slots[0] -= 1;
}
slot = path.slots[0];
found=btrfs_key_objectid(&path.nodes[0]->leaf.items[slot].key);
ret = del_item(root, &path);
ret = btrfs_del_item(root, &path);
count++;
if (ret) {
fprintf(stderr,
@ -182,7 +182,7 @@ static int empty_tree(struct ctree_root *root, struct radix_tree_root *radix,
found);
return -1;
}
release_path(root, &path);
btrfs_release_path(root, &path);
ptr = radix_tree_delete(radix, found);
if (!ptr)
goto error;
@ -195,7 +195,7 @@ error:
return -1;
}
static int fill_tree(struct ctree_root *root, struct radix_tree_root *radix,
static int fill_tree(struct btrfs_root *root, struct radix_tree_root *radix,
int count)
{
int i;
@ -207,7 +207,7 @@ static int fill_tree(struct ctree_root *root, struct radix_tree_root *radix,
goto out;
}
if (i % 1000 == 0) {
ret = commit_transaction(root, &super);
ret = btrfs_commit_transaction(root, &super);
if (ret) {
fprintf(stderr, "fill commit failed\n");
return ret;
@ -223,7 +223,7 @@ out:
return ret;
}
static int bulk_op(struct ctree_root *root, struct radix_tree_root *radix)
static int bulk_op(struct btrfs_root *root, struct radix_tree_root *radix)
{
int ret;
int nr = rand() % 5000;
@ -242,13 +242,13 @@ static int bulk_op(struct ctree_root *root, struct radix_tree_root *radix)
}
int (*ops[])(struct ctree_root *root, struct radix_tree_root *radix) =
int (*ops[])(struct btrfs_root *root, struct radix_tree_root *radix) =
{ ins_one, insert_dup, del_one, lookup_item,
lookup_enoent, bulk_op };
static int fill_radix(struct ctree_root *root, struct radix_tree_root *radix)
static int fill_radix(struct btrfs_root *root, struct radix_tree_root *radix)
{
struct ctree_path path;
struct btrfs_path path;
struct btrfs_key key;
unsigned long found;
int ret;
@ -259,16 +259,16 @@ static int fill_radix(struct ctree_root *root, struct radix_tree_root *radix)
key.flags = 0;
key.objectid = (unsigned long)-1;
while(1) {
init_path(&path);
ret = search_slot(root, &key, &path, 0, 0);
btrfs_init_path(&path);
ret = btrfs_search_slot(root, &key, &path, 0, 0);
if (ret < 0) {
release_path(root, &path);
btrfs_release_path(root, &path);
return ret;
}
slot = path.slots[0];
if (ret != 0) {
if (slot == 0) {
release_path(root, &path);
btrfs_release_path(root, &path);
break;
}
slot -= 1;
@ -287,7 +287,7 @@ static int fill_radix(struct ctree_root *root, struct radix_tree_root *radix)
radix_tree_preload_end();
}
release_path(root, &path);
btrfs_release_path(root, &path);
key.objectid = found - 1;
if (key.objectid > found)
break;
@ -312,7 +312,7 @@ int print_usage(void)
int main(int ac, char **av)
{
RADIX_TREE(radix, GFP_KERNEL);
struct ctree_root *root;
struct btrfs_root *root;
int i;
int ret;
int count;
@ -370,7 +370,7 @@ int main(int ac, char **av)
if (ret) {
fprintf(stderr, "op %d failed %d:%d\n",
op, i, iterations);
print_tree(root, root->node);
btrfs_print_tree(root, root->node);
fprintf(stderr, "op %d failed %d:%d\n",
op, i, iterations);
err = ret;