microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Mountable btrfs, with readdir 

Signed-off-by: Chris Mason <chris.mason@oracle.com>
This commit is contained in:
Chris Mason 2007-03-22 12:13:20 -04:00 коммит произвёл David Woodhouse
Родитель 2e635a2783
Коммит e20d96d64f
14 изменённых файлов: 659 добавлений и 498 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

5
fs/btrfs/Makefile
Просмотреть файл

@ -2,7 +2,8 @@ ifneq ($(KERNELRELEASE),)
# kbuild part of makefile
obj-m := btrfs.o
btrfs-y := super.o
btrfs-y := super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \
hash.o file-item.o inode-item.o inode-map.o disk-io.o
#btrfs-y := ctree.o disk-io.o radix-tree.o extent-tree.o print-tree.o \
# root-tree.o dir-item.o hash.o file-item.o inode-item.o \
@ -14,7 +15,7 @@ else
KERNELDIR := /lib/modules/`uname -r`/build
all::
$(MAKE) -C $(KERNELDIR) M=`pwd` modules
$(MAKE) C=1 -C $(KERNELDIR) M=`pwd` modules
clean::
rm *.o btrfs.ko
endif

273
fs/btrfs/ctree.c
Просмотреть файл

@ -7,11 +7,11 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_path *path, int data_size);
static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_buffer *dst, struct btrfs_buffer
*root, struct buffer_head *dst, struct buffer_head
*src);
static int balance_node_right(struct btrfs_trans_handle *trans, struct
btrfs_root *root, struct btrfs_buffer *dst_buf,
struct btrfs_buffer *src_buf);
btrfs_root *root, struct buffer_head *dst_buf,
struct buffer_head *src_buf);
static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct btrfs_path *path, int level, int slot);
@ -32,32 +32,34 @@ void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p)
}
static int btrfs_cow_block(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_buffer *buf, struct btrfs_buffer
*parent, int parent_slot, struct btrfs_buffer
*root, struct buffer_head *buf, struct buffer_head
*parent, int parent_slot, struct buffer_head
**cow_ret)
{
struct btrfs_buffer *cow;
struct buffer_head *cow;
struct btrfs_node *cow_node;
if (!list_empty(&buf->dirty)) {
if (!buffer_dirty(buf)) {
*cow_ret = buf;
return 0;
}
cow = btrfs_alloc_free_block(trans, root);
memcpy(&cow->node, &buf->node, root->blocksize);
btrfs_set_header_blocknr(&cow->node.header, cow->blocknr);
cow_node = btrfs_buffer_node(cow);
memcpy(cow_node, btrfs_buffer_node(buf), root->blocksize);
btrfs_set_header_blocknr(&cow_node->header, cow->b_blocknr);
*cow_ret = cow;
btrfs_inc_ref(trans, root, buf);
if (buf == root->node) {
root->node = cow;
cow->count++;
get_bh(cow);
if (buf != root->commit_root)
btrfs_free_extent(trans, root, buf->blocknr, 1, 1);
btrfs_free_extent(trans, root, buf->b_blocknr, 1, 1);
btrfs_block_release(root, buf);
} else {
btrfs_set_node_blockptr(&parent->node, parent_slot,
cow->blocknr);
BUG_ON(list_empty(&parent->dirty));
btrfs_free_extent(trans, root, buf->blocknr, 1, 1);
btrfs_set_node_blockptr(btrfs_buffer_node(parent), parent_slot,
cow->b_blocknr);
BUG_ON(!buffer_dirty(parent));
btrfs_free_extent(trans, root, buf->b_blocknr, 1, 1);
}
btrfs_block_release(root, buf);
return 0;
@ -119,12 +121,12 @@ static int check_node(struct btrfs_root *root, struct btrfs_path *path,
{
int i;
struct btrfs_node *parent = NULL;
struct btrfs_node *node = &path->nodes[level]->node;
struct btrfs_node *node = btrfs_buffer_node(path->nodes[level]);
int parent_slot;
u32 nritems = btrfs_header_nritems(&node->header);
if (path->nodes[level + 1])
parent = &path->nodes[level + 1]->node;
parent = btrfs_buffer_node(path->nodes[level + 1]);
parent_slot = path->slots[level + 1];
BUG_ON(nritems == 0);
if (parent) {
@ -148,13 +150,13 @@ static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
int level)
{
int i;
struct btrfs_leaf *leaf = &path->nodes[level]->leaf;
struct btrfs_leaf *leaf = btrfs_buffer_leaf(path->nodes[level]);
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 = btrfs_buffer_node(path->nodes[level + 1]);
parent_slot = path->slots[level + 1];
BUG_ON(btrfs_leaf_free_space(root, leaf) < 0);
@ -250,11 +252,11 @@ static int bin_search(struct btrfs_node *c, struct btrfs_key *key, int *slot)
return -1;
}
static struct btrfs_buffer *read_node_slot(struct btrfs_root *root,
struct btrfs_buffer *parent_buf,
static struct buffer_head *read_node_slot(struct btrfs_root *root,
struct buffer_head *parent_buf,
int slot)
{
struct btrfs_node *node = &parent_buf->node;
struct btrfs_node *node = btrfs_buffer_node(parent_buf);
if (slot < 0)
return NULL;
if (slot >= btrfs_header_nritems(&node->header))
@ -265,10 +267,10 @@ static struct btrfs_buffer *read_node_slot(struct btrfs_root *root,
static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_path *path, int level)
{
struct btrfs_buffer *right_buf;
struct btrfs_buffer *mid_buf;
struct btrfs_buffer *left_buf;
struct btrfs_buffer *parent_buf = NULL;
struct buffer_head *right_buf;
struct buffer_head *mid_buf;
struct buffer_head *left_buf;
struct buffer_head *parent_buf = NULL;
struct btrfs_node *right = NULL;
struct btrfs_node *mid;
struct btrfs_node *left = NULL;
@ -283,7 +285,7 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
return 0;
mid_buf = path->nodes[level];
mid = &mid_buf->node;
mid = btrfs_buffer_node(mid_buf);
orig_ptr = btrfs_node_blockptr(mid, orig_slot);
if (level < BTRFS_MAX_LEVEL - 1)
@ -295,8 +297,8 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
* by promoting the node below to a root
*/
if (!parent_buf) {
struct btrfs_buffer *child;
u64 blocknr = mid_buf->blocknr;
struct buffer_head *child;
u64 blocknr = mid_buf->b_blocknr;
if (btrfs_header_nritems(&mid->header) != 1)
return 0;
@ -313,7 +315,7 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
clean_tree_block(trans, root, mid_buf);
return btrfs_free_extent(trans, root, blocknr, 1, 1);
}
parent = &parent_buf->node;
parent = btrfs_buffer_node(parent_buf);
if (btrfs_header_nritems(&mid->header) >
BTRFS_NODEPTRS_PER_BLOCK(root) / 4)
@ -326,7 +328,7 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
if (left_buf) {
btrfs_cow_block(trans, root, left_buf, parent_buf, pslot - 1,
&left_buf);
left = &left_buf->node;
left = btrfs_buffer_node(left_buf);
orig_slot += btrfs_header_nritems(&left->header);
wret = push_node_left(trans, root, left_buf, mid_buf);
if (wret < 0)
@ -339,12 +341,12 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
if (right_buf) {
btrfs_cow_block(trans, root, right_buf, parent_buf, pslot + 1,
&right_buf);
right = &right_buf->node;
right = btrfs_buffer_node(right_buf);
wret = push_node_left(trans, root, mid_buf, right_buf);
if (wret < 0)
ret = wret;
if (btrfs_header_nritems(&right->header) == 0) {
u64 blocknr = right_buf->blocknr;
u64 blocknr = right_buf->b_blocknr;
btrfs_block_release(root, right_buf);
clean_tree_block(trans, root, right_buf);
right_buf = NULL;
@ -360,7 +362,7 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
memcpy(&parent->ptrs[pslot + 1].key,
&right->ptrs[0].key,
sizeof(struct btrfs_disk_key));
BUG_ON(list_empty(&parent_buf->dirty));
BUG_ON(!buffer_dirty(parent_buf));
}
}
if (btrfs_header_nritems(&mid->header) == 1) {
@ -381,7 +383,7 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
}
if (btrfs_header_nritems(&mid->header) == 0) {
/* we've managed to empty the middle node, drop it */
u64 blocknr = mid_buf->blocknr;
u64 blocknr = mid_buf->b_blocknr;
btrfs_block_release(root, mid_buf);
clean_tree_block(trans, root, mid_buf);
mid_buf = NULL;
@ -396,13 +398,13 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
/* update the parent key to reflect our changes */
memcpy(&parent->ptrs[pslot].key, &mid->ptrs[0].key,
sizeof(struct btrfs_disk_key));
BUG_ON(list_empty(&parent_buf->dirty));
BUG_ON(!buffer_dirty(parent_buf));
}
/* update the path */
if (left_buf) {
if (btrfs_header_nritems(&left->header) > orig_slot) {
left_buf->count++; // released below
get_bh(left_buf);
path->nodes[level] = left_buf;
path->slots[level + 1] -= 1;
path->slots[level] = orig_slot;
@ -415,8 +417,9 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root
}
/* double check we haven't messed things up */
check_block(root, path, level);
if (orig_ptr != btrfs_node_blockptr(&path->nodes[level]->node,
path->slots[level]))
if (orig_ptr !=
btrfs_node_blockptr(btrfs_buffer_node(path->nodes[level]),
path->slots[level]))
BUG();
if (right_buf)
@ -443,8 +446,8 @@ 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)
{
struct btrfs_buffer *b;
struct btrfs_buffer *cow_buf;
struct buffer_head *b;
struct buffer_head *cow_buf;
struct btrfs_node *c;
int slot;
int ret;
@ -452,18 +455,20 @@ int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
again:
b = root->node;
b->count++;
get_bh(b);
while (b) {
level = btrfs_header_level(&b->node.header);
c = btrfs_buffer_node(b);
level = btrfs_header_level(&c->header);
if (cow) {
int wret;
wret = btrfs_cow_block(trans, root, b, p->nodes[level +
1], p->slots[level + 1],
wret = btrfs_cow_block(trans, root, b,
p->nodes[level + 1],
p->slots[level + 1],
&cow_buf);
b = cow_buf;
}
BUG_ON(!cow && ins_len);
c = &b->node;
c = btrfs_buffer_node(b);
p->nodes[level] = b;
ret = check_block(root, p, level);
if (ret)
@ -480,7 +485,7 @@ again:
if (sret)
return sret;
b = p->nodes[level];
c = &b->node;
c = btrfs_buffer_node(b);
slot = p->slots[level];
} else if (ins_len < 0) {
int sret = balance_level(trans, root, p,
@ -490,7 +495,7 @@ again:
b = p->nodes[level];
if (!b)
goto again;
c = &b->node;
c = btrfs_buffer_node(b);
slot = p->slots[level];
BUG_ON(btrfs_header_nritems(&c->header) == 1);
}
@ -505,11 +510,9 @@ again:
if (sret)
return sret;
}
BUG_ON(root->node->count == 1);
return ret;
}
}
BUG_ON(root->node->count == 1);
return 1;
}
@ -534,9 +537,9 @@ static int fixup_low_keys(struct btrfs_trans_handle *trans, struct btrfs_root
int tslot = path->slots[i];
if (!path->nodes[i])
break;
t = &path->nodes[i]->node;
t = btrfs_buffer_node(path->nodes[i]);
memcpy(&t->ptrs[tslot].key, key, sizeof(*key));
BUG_ON(list_empty(&path->nodes[i]->dirty));
BUG_ON(!buffer_dirty(path->nodes[i]));
if (tslot != 0)
break;
}
@ -551,11 +554,11 @@ static int fixup_low_keys(struct btrfs_trans_handle *trans, struct btrfs_root
* error, and > 0 if there was no room in the left hand block.
*/
static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_buffer *dst_buf, struct
btrfs_buffer *src_buf)
*root, struct buffer_head *dst_buf, struct
buffer_head *src_buf)
{
struct btrfs_node *src = &src_buf->node;
struct btrfs_node *dst = &dst_buf->node;
struct btrfs_node *src = btrfs_buffer_node(src_buf);
struct btrfs_node *dst = btrfs_buffer_node(dst_buf);
int push_items = 0;
int src_nritems;
int dst_nritems;
@ -580,8 +583,8 @@ static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root
}
btrfs_set_header_nritems(&src->header, src_nritems - push_items);
btrfs_set_header_nritems(&dst->header, dst_nritems + push_items);
BUG_ON(list_empty(&src_buf->dirty));
BUG_ON(list_empty(&dst_buf->dirty));
BUG_ON(!buffer_dirty(src_buf));
BUG_ON(!buffer_dirty(dst_buf));
return ret;
}
@ -595,11 +598,11 @@ static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root
* this will only push up to 1/2 the contents of the left node over
*/
static int balance_node_right(struct btrfs_trans_handle *trans, struct
btrfs_root *root, struct btrfs_buffer *dst_buf,
struct btrfs_buffer *src_buf)
btrfs_root *root, struct buffer_head *dst_buf,
struct buffer_head *src_buf)
{
struct btrfs_node *src = &src_buf->node;
struct btrfs_node *dst = &dst_buf->node;
struct btrfs_node *src = btrfs_buffer_node(src_buf);
struct btrfs_node *dst = btrfs_buffer_node(dst_buf);
int push_items = 0;
int max_push;
int src_nritems;
@ -628,8 +631,8 @@ static int balance_node_right(struct btrfs_trans_handle *trans, struct
btrfs_set_header_nritems(&src->header, src_nritems - push_items);
btrfs_set_header_nritems(&dst->header, dst_nritems + push_items);
BUG_ON(list_empty(&src_buf->dirty));
BUG_ON(list_empty(&dst_buf->dirty));
BUG_ON(!buffer_dirty(src_buf));
BUG_ON(!buffer_dirty(dst_buf));
return ret;
}
@ -643,7 +646,7 @@ static int balance_node_right(struct btrfs_trans_handle *trans, struct
static int insert_new_root(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_path *path, int level)
{
struct btrfs_buffer *t;
struct buffer_head *t;
struct btrfs_node *lower;
struct btrfs_node *c;
struct btrfs_disk_key *lower_key;
@ -652,24 +655,24 @@ static int insert_new_root(struct btrfs_trans_handle *trans, struct btrfs_root
BUG_ON(path->nodes[level-1] != root->node);
t = btrfs_alloc_free_block(trans, root);
c = &t->node;
c = btrfs_buffer_node(t);
memset(c, 0, root->blocksize);
btrfs_set_header_nritems(&c->header, 1);
btrfs_set_header_level(&c->header, level);
btrfs_set_header_blocknr(&c->header, t->blocknr);
btrfs_set_header_blocknr(&c->header, t->b_blocknr);
btrfs_set_header_parentid(&c->header,
btrfs_header_parentid(&root->node->node.header));
lower = &path->nodes[level-1]->node;
btrfs_header_parentid(btrfs_buffer_header(root->node)));
lower = btrfs_buffer_node(path->nodes[level-1]);
if (btrfs_is_leaf(lower))
lower_key = &((struct btrfs_leaf *)lower)->items[0].key;
else
lower_key = &lower->ptrs[0].key;
memcpy(&c->ptrs[0].key, lower_key, sizeof(struct btrfs_disk_key));
btrfs_set_node_blockptr(c, 0, path->nodes[level - 1]->blocknr);
btrfs_set_node_blockptr(c, 0, path->nodes[level - 1]->b_blocknr);
/* the super has an extra ref to root->node */
btrfs_block_release(root, root->node);
root->node = t;
t->count++;
get_bh(t);
path->nodes[level] = t;
path->slots[level] = 0;
return 0;
@ -692,7 +695,7 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root
int nritems;
BUG_ON(!path->nodes[level]);
lower = &path->nodes[level]->node;
lower = btrfs_buffer_node(path->nodes[level]);
nritems = btrfs_header_nritems(&lower->header);
if (slot > nritems)
BUG();
@ -705,7 +708,7 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root
memcpy(&lower->ptrs[slot].key, key, sizeof(struct btrfs_disk_key));
btrfs_set_node_blockptr(lower, slot, blocknr);
btrfs_set_header_nritems(&lower->header, nritems + 1);
BUG_ON(list_empty(&path->nodes[level]->dirty));
BUG_ON(!buffer_dirty(path->nodes[level]));
return 0;
}
@ -721,9 +724,9 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root
static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_path *path, int level)
{
struct btrfs_buffer *t;
struct buffer_head *t;
struct btrfs_node *c;
struct btrfs_buffer *split_buffer;
struct buffer_head *split_buffer;
struct btrfs_node *split;
int mid;
int ret;
@ -731,7 +734,7 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
u32 c_nritems;
t = path->nodes[level];
c = &t->node;
c = btrfs_buffer_node(t);
if (t == root->node) {
/* trying to split the root, lets make a new one */
ret = insert_new_root(trans, root, path, level + 1);
@ -740,11 +743,11 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
}
c_nritems = btrfs_header_nritems(&c->header);
split_buffer = btrfs_alloc_free_block(trans, root);
split = &split_buffer->node;
split = btrfs_buffer_node(split_buffer);
btrfs_set_header_flags(&split->header, btrfs_header_flags(&c->header));
btrfs_set_header_blocknr(&split->header, split_buffer->blocknr);
btrfs_set_header_blocknr(&split->header, split_buffer->b_blocknr);
btrfs_set_header_parentid(&split->header,
btrfs_header_parentid(&root->node->node.header));
btrfs_header_parentid(btrfs_buffer_header(root->node)));
mid = (c_nritems + 1) / 2;
memcpy(split->ptrs, c->ptrs + mid,
(c_nritems - mid) * sizeof(struct btrfs_key_ptr));
@ -752,9 +755,9 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
btrfs_set_header_nritems(&c->header, mid);
ret = 0;
BUG_ON(list_empty(&t->dirty));
BUG_ON(!buffer_dirty(t));
wret = insert_ptr(trans, root, path, &split->ptrs[0].key,
split_buffer->blocknr, path->slots[level + 1] + 1,
split_buffer->b_blocknr, path->slots[level + 1] + 1,
level + 1);
if (wret)
ret = wret;
@ -798,11 +801,12 @@ static int leaf_space_used(struct btrfs_leaf *l, int start, int nr)
static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_path *path, int data_size)
{
struct btrfs_buffer *left_buf = path->nodes[0];
struct btrfs_leaf *left = &left_buf->leaf;
struct buffer_head *left_buf = path->nodes[0];
struct btrfs_leaf *left = btrfs_buffer_leaf(left_buf);
struct btrfs_leaf *right;
struct btrfs_buffer *right_buf;
struct btrfs_buffer *upper;
struct buffer_head *right_buf;
struct buffer_head *upper;
struct btrfs_node *upper_node;
int slot;
int i;
int free_space;
@ -817,12 +821,13 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
return 1;
}
upper = path->nodes[1];
if (slot >= btrfs_header_nritems(&upper->node.header) - 1) {
upper_node = btrfs_buffer_node(upper);
if (slot >= btrfs_header_nritems(&upper_node->header) - 1) {
return 1;
}
right_buf = read_tree_block(root, btrfs_node_blockptr(&upper->node,
slot + 1));
right = &right_buf->leaf;
right_buf = read_tree_block(root,
btrfs_node_blockptr(btrfs_buffer_node(upper), slot + 1));
right = btrfs_buffer_leaf(right_buf);
free_space = btrfs_leaf_free_space(root, right);
if (free_space < data_size + sizeof(struct btrfs_item)) {
btrfs_block_release(root, right_buf);
@ -830,7 +835,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
}
/* cow and double check */
btrfs_cow_block(trans, root, right_buf, upper, slot + 1, &right_buf);
right = &right_buf->leaf;
right = btrfs_buffer_leaf(right_buf);
free_space = btrfs_leaf_free_space(root, right);
if (free_space < data_size + sizeof(struct btrfs_item)) {
btrfs_block_release(root, right_buf);
@ -881,11 +886,11 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
left_nritems -= push_items;
btrfs_set_header_nritems(&left->header, left_nritems);
BUG_ON(list_empty(&left_buf->dirty));
BUG_ON(list_empty(&right_buf->dirty));
memcpy(&upper->node.ptrs[slot + 1].key,
BUG_ON(!buffer_dirty(left_buf));
BUG_ON(!buffer_dirty(right_buf));
memcpy(&upper_node->ptrs[slot + 1].key,
&right->items[0].key, sizeof(struct btrfs_disk_key));
BUG_ON(list_empty(&upper->dirty));
BUG_ON(!buffer_dirty(upper));
/* then fixup the leaf pointer in the path */
if (path->slots[0] >= left_nritems) {
@ -905,9 +910,9 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_path *path, int data_size)
{
struct btrfs_buffer *right_buf = path->nodes[0];
struct btrfs_leaf *right = &right_buf->leaf;
struct btrfs_buffer *t;
struct buffer_head *right_buf = path->nodes[0];
struct btrfs_leaf *right = btrfs_buffer_leaf(right_buf);
struct buffer_head *t;
struct btrfs_leaf *left;
int slot;
int i;
@ -926,9 +931,9 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
if (!path->nodes[1]) {
return 1;
}
t = read_tree_block(root, btrfs_node_blockptr(&path->nodes[1]->node,
slot - 1));
left = &t->leaf;
t = read_tree_block(root,
btrfs_node_blockptr(btrfs_buffer_node(path->nodes[1]), slot - 1));
left = btrfs_buffer_leaf(t);
free_space = btrfs_leaf_free_space(root, left);
if (free_space < data_size + sizeof(struct btrfs_item)) {
btrfs_block_release(root, t);
@ -937,7 +942,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
/* cow and double check */
btrfs_cow_block(trans, root, t, path->nodes[1], slot - 1, &t);
left = &t->leaf;
left = btrfs_buffer_leaf(t);
free_space = btrfs_leaf_free_space(root, left);
if (free_space < data_size + sizeof(struct btrfs_item)) {
btrfs_block_release(root, t);
@ -999,8 +1004,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
push_space = btrfs_item_offset(right->items + i);
}
BUG_ON(list_empty(&t->dirty));
BUG_ON(list_empty(&right_buf->dirty));
BUG_ON(!buffer_dirty(t));
BUG_ON(!buffer_dirty(right_buf));
wret = fixup_low_keys(trans, root, path, &right->items[0].key, 1);
if (wret)
@ -1029,13 +1034,13 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_path *path, int data_size)
{
struct btrfs_buffer *l_buf;
struct buffer_head *l_buf;
struct btrfs_leaf *l;
u32 nritems;
int mid;
int slot;
struct btrfs_leaf *right;
struct btrfs_buffer *right_buffer;
struct buffer_head *right_buffer;
int space_needed = data_size + sizeof(struct btrfs_item);
int data_copy_size;
int rt_data_off;
@ -1053,7 +1058,7 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
return wret;
}
l_buf = path->nodes[0];
l = &l_buf->leaf;
l = btrfs_buffer_leaf(l_buf);
/* did the pushes work? */
if (btrfs_leaf_free_space(root, l) >=
@ -1071,7 +1076,7 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
right_buffer = btrfs_alloc_free_block(trans, root);
BUG_ON(!right_buffer);
BUG_ON(mid == nritems);
right = &right_buffer->leaf;
right = btrfs_buffer_leaf(right_buffer);
memset(&right->header, 0, sizeof(right->header));
if (mid <= slot) {
/* FIXME, just alloc a new leaf here */
@ -1085,10 +1090,10 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
BUG();
}
btrfs_set_header_nritems(&right->header, nritems - mid);
btrfs_set_header_blocknr(&right->header, right_buffer->blocknr);
btrfs_set_header_blocknr(&right->header, right_buffer->b_blocknr);
btrfs_set_header_level(&right->header, 0);
btrfs_set_header_parentid(&right->header,
btrfs_header_parentid(&root->node->node.header));
btrfs_header_parentid(btrfs_buffer_header(root->node)));
data_copy_size = btrfs_item_end(l->items + mid) -
leaf_data_end(root, l);
memcpy(right->items, l->items + mid,
@ -1107,11 +1112,11 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
btrfs_set_header_nritems(&l->header, mid);
ret = 0;
wret = insert_ptr(trans, root, path, &right->items[0].key,
right_buffer->blocknr, path->slots[1] + 1, 1);
right_buffer->b_blocknr, path->slots[1] + 1, 1);
if (wret)
ret = wret;
BUG_ON(list_empty(&right_buffer->dirty));
BUG_ON(list_empty(&l_buf->dirty));
BUG_ON(!buffer_dirty(right_buffer));
BUG_ON(!buffer_dirty(l_buf));
BUG_ON(path->slots[0] != slot);
if (mid <= slot) {
btrfs_block_release(root, path->nodes[0]);
@ -1136,7 +1141,7 @@ int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root
int slot;
int slot_orig;
struct btrfs_leaf *leaf;
struct btrfs_buffer *leaf_buf;
struct buffer_head *leaf_buf;
u32 nritems;
unsigned int data_end;
struct btrfs_disk_key disk_key;
@ -1156,7 +1161,7 @@ int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root
slot_orig = path->slots[0];
leaf_buf = path->nodes[0];
leaf = &leaf_buf->leaf;
leaf = btrfs_buffer_leaf(leaf_buf);
nritems = btrfs_header_nritems(&leaf->header);
data_end = leaf_data_end(root, leaf);
@ -1202,7 +1207,7 @@ int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root
if (slot == 0)
ret = fixup_low_keys(trans, root, path, &disk_key, 1);
BUG_ON(list_empty(&leaf_buf->dirty));
BUG_ON(!buffer_dirty(leaf_buf));
if (btrfs_leaf_free_space(root, leaf) < 0)
BUG();
check_leaf(root, path, 0);
@ -1225,7 +1230,8 @@ int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
btrfs_init_path(&path);
ret = btrfs_insert_empty_item(trans, root, &path, cpu_key, data_size);
if (!ret) {
ptr = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0], u8);
ptr = btrfs_item_ptr(btrfs_buffer_leaf(path.nodes[0]),
path.slots[0], u8);
memcpy(ptr, data, data_size);
}
btrfs_release_path(root, &path);
@ -1243,12 +1249,12 @@ static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct btrfs_path *path, int level, int slot)
{
struct btrfs_node *node;
struct btrfs_buffer *parent = path->nodes[level];
struct buffer_head *parent = path->nodes[level];
u32 nritems;
int ret = 0;
int wret;
node = &parent->node;
node = btrfs_buffer_node(parent);
nritems = btrfs_header_nritems(&node->header);
if (slot != nritems -1) {
memmove(node->ptrs + slot, node->ptrs + slot + 1,
@ -1257,16 +1263,17 @@ static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
nritems--;
btrfs_set_header_nritems(&node->header, nritems);
if (nritems == 0 && parent == root->node) {
BUG_ON(btrfs_header_level(&root->node->node.header) != 1);
struct btrfs_header *header = btrfs_buffer_header(root->node);
BUG_ON(btrfs_header_level(header) != 1);
/* just turn the root into a leaf and break */
btrfs_set_header_level(&root->node->node.header, 0);
btrfs_set_header_level(header, 0);
} else if (slot == 0) {
wret = fixup_low_keys(trans, root, path, &node->ptrs[0].key,
level + 1);
if (wret)
ret = wret;
}
BUG_ON(list_empty(&parent->dirty));
BUG_ON(!buffer_dirty(parent));
return ret;
}
@ -1279,7 +1286,7 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
{
int slot;
struct btrfs_leaf *leaf;
struct btrfs_buffer *leaf_buf;
struct buffer_head *leaf_buf;
int doff;
int dsize;
int ret = 0;
@ -1287,7 +1294,7 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
u32 nritems;
leaf_buf = path->nodes[0];
leaf = &leaf_buf->leaf;
leaf = btrfs_buffer_leaf(leaf_buf);
slot = path->slots[0];
doff = btrfs_item_offset(leaf->items + slot);
dsize = btrfs_item_size(leaf->items + slot);
@ -1313,14 +1320,13 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
if (nritems == 0) {
if (leaf_buf == root->node) {
btrfs_set_header_level(&leaf->header, 0);
BUG_ON(list_empty(&leaf_buf->dirty));
} else {
clean_tree_block(trans, root, leaf_buf);
wret = del_ptr(trans, root, path, 1, path->slots[1]);
if (wret)
ret = wret;
wret = btrfs_free_extent(trans, root,
leaf_buf->blocknr, 1, 1);
leaf_buf->b_blocknr, 1, 1);
if (wret)
ret = wret;
}
@ -1332,7 +1338,6 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
if (wret)
ret = wret;
}
BUG_ON(list_empty(&leaf_buf->dirty));
/* delete the leaf if it is mostly empty */
if (used < BTRFS_LEAF_DATA_SIZE(root) / 3) {
@ -1341,7 +1346,7 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
* for possible call to del_ptr below
*/
slot = path->slots[1];
leaf_buf->count++;
get_bh(leaf_buf);
wret = push_leaf_left(trans, root, path, 1);
if (wret < 0)
ret = wret;
@ -1352,7 +1357,7 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
ret = wret;
}
if (btrfs_header_nritems(&leaf->header) == 0) {
u64 blocknr = leaf_buf->blocknr;
u64 blocknr = leaf_buf->b_blocknr;
clean_tree_block(trans, root, leaf_buf);
wret = del_ptr(trans, root, path, 1, slot);
if (wret)
@ -1380,19 +1385,21 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
int slot;
int level = 1;
u64 blocknr;
struct btrfs_buffer *c;
struct btrfs_buffer *next = NULL;
struct buffer_head *c;
struct btrfs_node *c_node;
struct buffer_head *next = NULL;
while(level < BTRFS_MAX_LEVEL) {
if (!path->nodes[level])
return 1;
slot = path->slots[level] + 1;
c = path->nodes[level];
if (slot >= btrfs_header_nritems(&c->node.header)) {
c_node = btrfs_buffer_node(c);
if (slot >= btrfs_header_nritems(&c_node->header)) {
level++;
continue;
}
blocknr = btrfs_node_blockptr(&c->node, slot);
blocknr = btrfs_node_blockptr(c_node, slot);
if (next)
btrfs_block_release(root, next);
next = read_tree_block(root, blocknr);
@ -1408,7 +1415,7 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
if (!level)
break;
next = read_tree_block(root,
btrfs_node_blockptr(&next->node, 0));
btrfs_node_blockptr(btrfs_buffer_node(next), 0));
}
return 0;
}

62
fs/btrfs/ctree.h
Просмотреть файл

@ -1,6 +1,9 @@
#ifndef __BTRFS__
#define __BTRFS__
#include <linux/radix-tree.h>
#include <linux/fs.h>
struct btrfs_trans_handle;
#define BTRFS_MAGIC "_BtRfS_M"
@ -10,6 +13,12 @@ struct btrfs_trans_handle;
#define BTRFS_INODE_MAP_OBJECTID 3
#define BTRFS_FS_TREE_OBJECTID 4
/*
* we can actually store much bigger names, but lets not confuse the rest
* of linux
*/
#define BTRFS_NAME_LEN 255
/*
* the key defines the order in the tree, and so it also defines (optimal)
* block layout. objectid corresonds to the inode number. The flags
@ -57,7 +66,7 @@ struct btrfs_header {
#define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->blocksize))
struct btrfs_buffer;
struct buffer_head;
/*
* the super block basically lists the main trees of the FS
* it currently lacks any block count etc etc
@ -120,7 +129,7 @@ struct btrfs_node {
* used while walking the tree.
*/
struct btrfs_path {
struct btrfs_buffer *nodes[BTRFS_MAX_LEVEL];
struct buffer_head *nodes[BTRFS_MAX_LEVEL];
int slots[BTRFS_MAX_LEVEL];
};
@ -211,17 +220,14 @@ struct btrfs_fs_info {
struct btrfs_root *inode_root;
struct btrfs_key current_insert;
struct btrfs_key last_insert;
struct radix_tree_root cache_radix;
struct radix_tree_root pinned_radix;
struct list_head trans;
struct list_head cache;
u64 last_inode_alloc;
u64 last_inode_alloc_dirid;
u64 generation;
int cache_size;
int fp;
struct btrfs_trans_handle *running_transaction;
struct btrfs_super_block *disk_super;
struct buffer_head *sb_buffer;
struct super_block *sb;
};
/*
@ -230,8 +236,8 @@ struct btrfs_fs_info {
* only for the extent tree.
*/
struct btrfs_root {
struct btrfs_buffer *node;
struct btrfs_buffer *commit_root;
struct buffer_head *node;
struct buffer_head *commit_root;
struct btrfs_root_item root_item;
struct btrfs_key root_key;
struct btrfs_fs_info *fs_info;
@ -389,6 +395,29 @@ static inline void btrfs_set_inode_compat_flags(struct btrfs_inode_item *i,
i->compat_flags = cpu_to_le16(val);
}
static inline u32 btrfs_timespec_sec(struct btrfs_inode_timespec *ts)
{
return le32_to_cpu(ts->sec);
}
static inline void btrfs_set_timespec_sec(struct btrfs_inode_timespec *ts,
u32 val)
{
ts->sec = cpu_to_le32(val);
}
static inline u32 btrfs_timespec_nsec(struct btrfs_inode_timespec *ts)
{
return le32_to_cpu(ts->nsec);
}
static inline void btrfs_set_timespec_nsec(struct btrfs_inode_timespec *ts,
u32 val)
{
ts->nsec = cpu_to_le32(val);
}
static inline u64 btrfs_extent_owner(struct btrfs_extent_item *ei)
{
@ -757,15 +786,20 @@ static inline void btrfs_set_file_extent_num_blocks(struct
e->num_blocks = cpu_to_le64(val);
}
static inline struct btrfs_root *btrfs_sb(struct super_block *sb)
{
return sb->s_fs_info;
}
/* helper function to cast into the data area of the leaf. */
#define btrfs_item_ptr(leaf, slot, type) \
((type *)(btrfs_leaf_data(leaf) + \
btrfs_item_offset((leaf)->items + (slot))))
struct btrfs_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
struct buffer_head *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
struct btrfs_root *root);
int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct btrfs_buffer *buf);
struct buffer_head *buf);
int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
*root, u64 blocknr, u64 num_blocks, int pin);
int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
@ -783,7 +817,7 @@ int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root
int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf);
int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_buffer *snap);
*root, struct buffer_head *snap);
int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, struct
btrfs_root *root);
int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
@ -800,8 +834,8 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
*root, char *name, int name_len, u64 dir, u64
objectid, u8 type);
int btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_path *path, u64 dir, char *name,
int name_len, int mod);
*root, struct btrfs_path *path, u64 dir,
const char *name, int name_len, int mod);
int btrfs_match_dir_item_name(struct btrfs_root *root, struct btrfs_path *path,
char *name, int name_len);
int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,

17
fs/btrfs/dir-item.c
Просмотреть файл

@ -18,12 +18,7 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
key.objectid = dir;
key.flags = 0;
btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
if (name_len == 1 && *name == '.')
key.offset = 1;
else if (name_len == 2 && name[0] == '.' && name[1] == '.')
key.offset = 2;
else
ret = btrfs_name_hash(name, name_len, &key.offset);
ret = btrfs_name_hash(name, name_len, &key.offset);
BUG_ON(ret);
btrfs_init_path(&path);
data_size = sizeof(*dir_item) + name_len;
@ -31,7 +26,8 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
if (ret)
goto out;
dir_item = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
dir_item = btrfs_item_ptr(btrfs_buffer_leaf(path.nodes[0]),
path.slots[0],
struct btrfs_dir_item);
btrfs_set_dir_objectid(dir_item, objectid);
btrfs_set_dir_type(dir_item, type);
@ -45,8 +41,8 @@ out:
}
int btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_path *path, u64 dir, char *name,
int name_len, int mod)
*root, struct btrfs_path *path, u64 dir,
const char *name, int name_len, int mod)
{
int ret;
struct btrfs_key key;
@ -69,7 +65,8 @@ int btrfs_match_dir_item_name(struct btrfs_root *root,
struct btrfs_dir_item *dir_item;
char *name_ptr;
dir_item = btrfs_item_ptr(&path->nodes[0]->leaf, path->slots[0],
dir_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
path->slots[0],
struct btrfs_dir_item);
if (btrfs_dir_name_len(dir_item) != name_len)
return 0;

283
fs/btrfs/disk-io.c
Просмотреть файл

@ -1,165 +1,67 @@
#define _XOPEN_SOURCE 500
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "kerncompat.h"
#include "radix-tree.h"
#include <linux/module.h>
#include <linux/fs.h>
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
static int allocated_blocks = 0;
int cache_max = 10000;
static int check_tree_block(struct btrfs_root *root, struct btrfs_buffer *buf)
static int check_tree_block(struct btrfs_root *root, struct buffer_head *buf)
{
if (buf->blocknr != btrfs_header_blocknr(&buf->node.header))
struct btrfs_node *node = btrfs_buffer_node(buf);
if (buf->b_blocknr != btrfs_header_blocknr(&node->header))
BUG();
if (root->node && btrfs_header_parentid(&buf->node.header) !=
btrfs_header_parentid(&root->node->node.header))
if (root->node && btrfs_header_parentid(&node->header) !=
btrfs_header_parentid(btrfs_buffer_header(root->node)))
BUG();
return 0;
}
static int free_some_buffers(struct btrfs_root *root)
struct buffer_head *alloc_tree_block(struct btrfs_root *root, u64 blocknr)
{
struct list_head *node, *next;
struct btrfs_buffer *b;
if (root->fs_info->cache_size < cache_max)
return 0;
list_for_each_safe(node, next, &root->fs_info->cache) {
b = list_entry(node, struct btrfs_buffer, cache);
if (b->count == 1) {
BUG_ON(!list_empty(&b->dirty));
list_del_init(&b->cache);
btrfs_block_release(root, b);
if (root->fs_info->cache_size < cache_max)
break;
}
}
return 0;
return sb_getblk(root->fs_info->sb, blocknr);
}
struct btrfs_buffer *alloc_tree_block(struct btrfs_root *root, u64 blocknr)
struct buffer_head *find_tree_block(struct btrfs_root *root, u64 blocknr)
{
struct btrfs_buffer *buf;
int ret;
return sb_getblk(root->fs_info->sb, blocknr);
}
struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr)
{
struct buffer_head *buf = sb_bread(root->fs_info->sb, blocknr);
buf = malloc(sizeof(struct btrfs_buffer) + root->blocksize);
if (!buf)
return buf;
allocated_blocks++;
buf->blocknr = blocknr;
buf->count = 2;
INIT_LIST_HEAD(&buf->dirty);
free_some_buffers(root);
radix_tree_preload(GFP_KERNEL);
ret = radix_tree_insert(&root->fs_info->cache_radix, blocknr, buf);
radix_tree_preload_end();
list_add_tail(&buf->cache, &root->fs_info->cache);
root->fs_info->cache_size++;
if (ret) {
free(buf);
return NULL;
}
return buf;
}
struct btrfs_buffer *find_tree_block(struct btrfs_root *root, u64 blocknr)
{
struct btrfs_buffer *buf;
buf = radix_tree_lookup(&root->fs_info->cache_radix, blocknr);
if (buf) {
buf->count++;
} else {
buf = alloc_tree_block(root, blocknr);
if (!buf) {
BUG();
return NULL;
}
}
return buf;
}
struct btrfs_buffer *read_tree_block(struct btrfs_root *root, u64 blocknr)
{
loff_t offset = blocknr * root->blocksize;
struct btrfs_buffer *buf;
int ret;
buf = radix_tree_lookup(&root->fs_info->cache_radix, blocknr);
if (buf) {
buf->count++;
} else {
buf = alloc_tree_block(root, blocknr);
if (!buf)
return NULL;
ret = pread(root->fs_info->fp, &buf->node, root->blocksize,
offset);
if (ret != root->blocksize) {
free(buf);
return NULL;
}
}
if (check_tree_block(root, buf))
BUG();
return buf;
}
int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct btrfs_buffer *buf)
struct buffer_head *buf)
{
if (!list_empty(&buf->dirty))
return 0;
list_add_tail(&buf->dirty, &root->fs_info->trans);
buf->count++;
mark_buffer_dirty(buf);
return 0;
}
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct btrfs_buffer *buf)
struct buffer_head *buf)
{
if (!list_empty(&buf->dirty)) {
list_del_init(&buf->dirty);
btrfs_block_release(root, buf);
}
clear_buffer_dirty(buf);
return 0;
}
int write_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct btrfs_buffer *buf)
struct buffer_head *buf)
{
u64 blocknr = buf->blocknr;
loff_t offset = blocknr * root->blocksize;
int ret;
if (buf->blocknr != btrfs_header_blocknr(&buf->node.header))
BUG();
ret = pwrite(root->fs_info->fp, &buf->node, root->blocksize, offset);
if (ret != root->blocksize)
return ret;
mark_buffer_dirty(buf);
return 0;
}
static int __commit_transaction(struct btrfs_trans_handle *trans, struct
btrfs_root *root)
{
struct btrfs_buffer *b;
int ret = 0;
int wret;
while(!list_empty(&root->fs_info->trans)) {
b = list_entry(root->fs_info->trans.next, struct btrfs_buffer,
dirty);
list_del_init(&b->dirty);
wret = write_tree_block(trans, root, b);
if (wret)
ret = wret;
btrfs_block_release(root, b);
}
return ret;
filemap_write_and_wait(root->fs_info->sb->s_bdev->bd_inode->i_mapping);
return 0;
}
static int commit_tree_roots(struct btrfs_trans_handle *trans,
@ -172,17 +74,17 @@ static int commit_tree_roots(struct btrfs_trans_handle *trans,
struct btrfs_root *inode_root = fs_info->inode_root;
btrfs_set_root_blocknr(&inode_root->root_item,
inode_root->node->blocknr);
inode_root->node->b_blocknr);
ret = btrfs_update_root(trans, tree_root,
&inode_root->root_key,
&inode_root->root_item);
BUG_ON(ret);
while(1) {
old_extent_block = btrfs_root_blocknr(&extent_root->root_item);
if (old_extent_block == extent_root->node->blocknr)
if (old_extent_block == extent_root->node->b_blocknr)
break;
btrfs_set_root_blocknr(&extent_root->root_item,
extent_root->node->blocknr);
extent_root->node->b_blocknr);
ret = btrfs_update_root(trans, tree_root,
&extent_root->root_key,
&extent_root->root_item);
@ -195,7 +97,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct
btrfs_root *root, struct btrfs_super_block *s)
{
int ret = 0;
struct btrfs_buffer *snap = root->commit_root;
struct buffer_head *snap = root->commit_root;
struct btrfs_key snap_key;
if (root->commit_root == root->node)
@ -204,7 +106,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct
memcpy(&snap_key, &root->root_key, sizeof(snap_key));
root->root_key.offset++;
btrfs_set_root_blocknr(&root->root_item, root->node->blocknr);
btrfs_set_root_blocknr(&root->root_item, root->node->b_blocknr);
ret = btrfs_insert_root(trans, root->fs_info->tree_root,
&root->root_key, &root->root_item);
BUG_ON(ret);
@ -220,7 +122,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct
btrfs_finish_extent_commit(trans, root->fs_info->tree_root);
root->commit_root = root->node;
root->node->count++;
get_bh(root->node);
ret = btrfs_drop_snapshot(trans, root, snap);
BUG_ON(ret);
@ -234,7 +136,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct
static int __setup_root(struct btrfs_super_block *super,
struct btrfs_root *root,
struct btrfs_fs_info *fs_info,
u64 objectid, int fp)
u64 objectid)
{
root->node = NULL;
root->commit_root = NULL;
@ -250,11 +152,11 @@ static int find_and_setup_root(struct btrfs_super_block *super,
struct btrfs_root *tree_root,
struct btrfs_fs_info *fs_info,
u64 objectid,
struct btrfs_root *root, int fp)
struct btrfs_root *root)
{
int ret;
__setup_root(super, root, fs_info, objectid, fp);
__setup_root(super, root, fs_info, objectid);
ret = btrfs_find_last_root(tree_root, objectid,
&root->root_item, &root->root_key);
BUG_ON(ret);
@ -265,32 +167,26 @@ static int find_and_setup_root(struct btrfs_super_block *super,
return 0;
}
struct btrfs_root *open_ctree(char *filename, struct btrfs_super_block *super)
struct btrfs_root *open_ctree(struct super_block *sb,
struct buffer_head *sb_buffer,
struct btrfs_super_block *disk_super)
{
int fp;
fp = open(filename, O_CREAT | O_RDWR, 0600);
if (fp < 0) {
return NULL;
}
return open_ctree_fd(fp, super);
}
struct btrfs_root *open_ctree_fd(int fp, struct btrfs_super_block *super)
{
struct btrfs_root *root = malloc(sizeof(struct btrfs_root));
struct btrfs_root *extent_root = malloc(sizeof(struct btrfs_root));
struct btrfs_root *tree_root = malloc(sizeof(struct btrfs_root));
struct btrfs_root *inode_root = malloc(sizeof(struct btrfs_root));
struct btrfs_fs_info *fs_info = malloc(sizeof(*fs_info));
struct btrfs_root *root = kmalloc(sizeof(struct btrfs_root),
GFP_NOFS);
struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
GFP_NOFS);
struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
GFP_NOFS);
struct btrfs_root *inode_root = kmalloc(sizeof(struct btrfs_root),
GFP_NOFS);
struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info),
GFP_NOFS);
int ret;
INIT_RADIX_TREE(&fs_info->cache_radix, GFP_KERNEL);
/* FIXME: don't be stupid */
if (!btrfs_super_root(disk_super))
return NULL;
INIT_RADIX_TREE(&fs_info->pinned_radix, GFP_KERNEL);
INIT_LIST_HEAD(&fs_info->trans);
INIT_LIST_HEAD(&fs_info->cache);
fs_info->cache_size = 0;
fs_info->fp = fp;
fs_info->running_transaction = NULL;
fs_info->fs_root = root;
fs_info->tree_root = tree_root;
@ -298,36 +194,31 @@ struct btrfs_root *open_ctree_fd(int fp, struct btrfs_super_block *super)
fs_info->inode_root = inode_root;
fs_info->last_inode_alloc = 0;
fs_info->last_inode_alloc_dirid = 0;
fs_info->disk_super = super;
fs_info->disk_super = disk_super;
fs_info->sb_buffer = sb_buffer;
fs_info->sb = sb;
memset(&fs_info->current_insert, 0, sizeof(fs_info->current_insert));
memset(&fs_info->last_insert, 0, sizeof(fs_info->last_insert));
ret = pread(fp, super, sizeof(struct btrfs_super_block),
BTRFS_SUPER_INFO_OFFSET);
if (ret == 0 || btrfs_super_root(super) == 0) {
BUG();
return NULL;
}
BUG_ON(ret < 0);
__setup_root(super, tree_root, fs_info, BTRFS_ROOT_TREE_OBJECTID, fp);
tree_root->node = read_tree_block(tree_root, btrfs_super_root(super));
__setup_root(disk_super, tree_root, fs_info, BTRFS_ROOT_TREE_OBJECTID);
tree_root->node = read_tree_block(tree_root,
btrfs_super_root(disk_super));
BUG_ON(!tree_root->node);
ret = find_and_setup_root(super, tree_root, fs_info,
BTRFS_EXTENT_TREE_OBJECTID, extent_root, fp);
ret = find_and_setup_root(disk_super, tree_root, fs_info,
BTRFS_EXTENT_TREE_OBJECTID, extent_root);
BUG_ON(ret);
ret = find_and_setup_root(super, tree_root, fs_info,
BTRFS_INODE_MAP_OBJECTID, inode_root, fp);
ret = find_and_setup_root(disk_super, tree_root, fs_info,
BTRFS_INODE_MAP_OBJECTID, inode_root);
BUG_ON(ret);
ret = find_and_setup_root(super, tree_root, fs_info,
BTRFS_FS_TREE_OBJECTID, root, fp);
ret = find_and_setup_root(disk_super, tree_root, fs_info,
BTRFS_FS_TREE_OBJECTID, root);
BUG_ON(ret);
root->commit_root = root->node;
root->node->count++;
get_bh(root->node);
root->ref_cows = 1;
root->fs_info->generation = root->root_key.offset + 1;
return root;
@ -336,8 +227,11 @@ struct btrfs_root *open_ctree_fd(int fp, struct btrfs_super_block *super)
int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_super_block *s)
{
return 0;
#if 0
int ret;
btrfs_set_super_root(s, root->fs_info->tree_root->node->blocknr);
btrfs_set_super_root(s, root->fs_info->tree_root->node->b_blocknr);
ret = pwrite(root->fs_info->fp, s, sizeof(*s),
BTRFS_SUPER_INFO_OFFSET);
if (ret != sizeof(*s)) {
@ -345,35 +239,38 @@ int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
return ret;
}
return 0;
#endif
}
static int drop_cache(struct btrfs_root *root)
{
return 0;
#if 0
while(!list_empty(&root->fs_info->cache)) {
struct btrfs_buffer *b = list_entry(root->fs_info->cache.next,
struct btrfs_buffer,
struct buffer_head *b = list_entry(root->fs_info->cache.next,
struct buffer_head,
cache);
list_del_init(&b->cache);
btrfs_block_release(root, b);
}
return 0;
#endif
}
int close_ctree(struct btrfs_root *root, struct btrfs_super_block *s)
int close_ctree(struct btrfs_root *root)
{
int ret;
struct btrfs_trans_handle *trans;
trans = root->fs_info->running_transaction;
btrfs_commit_transaction(trans, root, s);
btrfs_commit_transaction(trans, root, root->fs_info->disk_super);
ret = commit_tree_roots(trans, root->fs_info);
BUG_ON(ret);
ret = __commit_transaction(trans, root);
BUG_ON(ret);
write_ctree_super(trans, root, s);
write_ctree_super(trans, root, root->fs_info->disk_super);
drop_cache(root);
BUG_ON(!list_empty(&root->fs_info->trans));
close(root->fs_info->fp);
if (root->node)
btrfs_block_release(root, root->node);
if (root->fs_info->extent_root->node)
@ -386,29 +283,17 @@ int close_ctree(struct btrfs_root *root, struct btrfs_super_block *s)
btrfs_block_release(root->fs_info->tree_root,
root->fs_info->tree_root->node);
btrfs_block_release(root, root->commit_root);
free(root);
printf("on close %d blocks are allocated\n", allocated_blocks);
btrfs_block_release(root, root->fs_info->sb_buffer);
kfree(root->fs_info->extent_root);
kfree(root->fs_info->inode_root);
kfree(root->fs_info->tree_root);
kfree(root->fs_info);
kfree(root);
return 0;
}
void btrfs_block_release(struct btrfs_root *root, struct btrfs_buffer *buf)
void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf)
{
buf->count--;
if (buf->count < 0)
BUG();
if (buf->count == 0) {
BUG_ON(!list_empty(&buf->cache));
BUG_ON(!list_empty(&buf->dirty));
if (!radix_tree_lookup(&root->fs_info->cache_radix,
buf->blocknr))
BUG();
radix_tree_delete(&root->fs_info->cache_radix, buf->blocknr);
memset(buf, 0, sizeof(*buf));
free(buf);
BUG_ON(allocated_blocks == 0);
allocated_blocks--;
BUG_ON(root->fs_info->cache_size == 0);
root->fs_info->cache_size--;
}
brelse(buf);
}

63
fs/btrfs/disk-io.h
Просмотреть файл

@ -1,36 +1,41 @@
#ifndef __DISKIO__
#define __DISKIO__
#include "list.h"
struct btrfs_buffer {
u64 blocknr;
int count;
struct list_head dirty;
struct list_head cache;
union {
struct btrfs_node node;
struct btrfs_leaf leaf;
};
};
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_trans_handle *trans, struct btrfs_root *root,
struct btrfs_buffer *buf);
int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct btrfs_buffer *buf);
int clean_tree_block(struct btrfs_trans_handle *trans,
struct btrfs_root *root, struct btrfs_buffer *buf);
int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_super_block *s);
struct btrfs_root *open_ctree(char *filename, struct btrfs_super_block *s);
struct btrfs_root *open_ctree_fd(int fp, struct btrfs_super_block *super);
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_trans_handle *trans, struct btrfs_root *root,
struct btrfs_super_block *s);
int mkfs(int fd, u64 num_blocks, u32 blocksize);
#include <linux/buffer_head.h>
#define BTRFS_SUPER_INFO_OFFSET (16 * 1024)
static inline struct btrfs_node *btrfs_buffer_node(struct buffer_head *bh)
{
return (struct btrfs_node *)bh->b_data;
}
static inline struct btrfs_leaf *btrfs_buffer_leaf(struct buffer_head *bh)
{
return (struct btrfs_leaf *)bh->b_data;
}
static inline struct btrfs_header *btrfs_buffer_header(struct buffer_head *bh)
{
return &((struct btrfs_node *)bh->b_data)->header;
}
struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr);
struct buffer_head *find_tree_block(struct btrfs_root *root, u64 blocknr);
int write_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct buffer_head *buf);
int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct buffer_head *buf);
int clean_tree_block(struct btrfs_trans_handle *trans,
struct btrfs_root *root, struct buffer_head *buf);
int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_super_block *s);
struct btrfs_root *open_ctree(struct super_block *sb,
struct buffer_head *sb_buffer,
struct btrfs_super_block *disk_super);
int close_ctree(struct btrfs_root *root);
void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf);
int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct btrfs_super_block *s);
int mkfs(int fd, u64 num_blocks, u32 blocksize);
#endif

144
fs/btrfs/extent-tree.c
Просмотреть файл

@ -10,9 +10,8 @@ static int find_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
search_end, struct btrfs_key *ins);
static int finish_current_insert(struct btrfs_trans_handle *trans, struct
btrfs_root *extent_root);
static int run_pending(struct btrfs_trans_handle *trans, struct btrfs_root
*extent_root);
static int del_pending_extents(struct btrfs_trans_handle *trans, struct
btrfs_root *extent_root);
/*
* pending extents are blocks that we're trying to allocate in the extent
* map while trying to grow the map because of other allocations. To avoid
@ -21,6 +20,7 @@ static int run_pending(struct btrfs_trans_handle *trans, struct btrfs_root
* manner for deletes.
*/
#define CTREE_EXTENT_PENDING_DEL 0
#define CTREE_EXTENT_PINNED 1
static int inc_block_ref(struct btrfs_trans_handle *trans, struct btrfs_root
*root, u64 blocknr)
@ -45,15 +45,14 @@ static int inc_block_ref(struct btrfs_trans_handle *trans, struct btrfs_root
if (ret != 0)
BUG();
BUG_ON(ret != 0);
l = &path.nodes[0]->leaf;
l = btrfs_buffer_leaf(path.nodes[0]);
item = btrfs_item_ptr(l, path.slots[0], struct btrfs_extent_item);
refs = btrfs_extent_refs(item);
btrfs_set_extent_refs(item, refs + 1);
BUG_ON(list_empty(&path.nodes[0]->dirty));
btrfs_release_path(root->fs_info->extent_root, &path);
finish_current_insert(trans, root->fs_info->extent_root);
run_pending(trans, root->fs_info->extent_root);
del_pending_extents(trans, root->fs_info->extent_root);
return 0;
}
@ -74,7 +73,7 @@ static int lookup_block_ref(struct btrfs_trans_handle *trans, struct btrfs_root
0, 0);
if (ret != 0)
BUG();
l = &path.nodes[0]->leaf;
l = btrfs_buffer_leaf(path.nodes[0]);
item = btrfs_item_ptr(l, path.slots[0], struct btrfs_extent_item);
*refs = btrfs_extent_refs(item);
btrfs_release_path(root->fs_info->extent_root, &path);
@ -82,18 +81,20 @@ static int lookup_block_ref(struct btrfs_trans_handle *trans, struct btrfs_root
}
int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct btrfs_buffer *buf)
struct buffer_head *buf)
{
u64 blocknr;
struct btrfs_node *buf_node;
int i;
if (!root->ref_cows)
return 0;
if (btrfs_is_leaf(&buf->node))
buf_node = btrfs_buffer_node(buf);
if (btrfs_is_leaf(buf_node))
return 0;
for (i = 0; i < btrfs_header_nritems(&buf->node.header); i++) {
blocknr = btrfs_node_blockptr(&buf->node, i);
for (i = 0; i < btrfs_header_nritems(&buf_node->header); i++) {
blocknr = btrfs_node_blockptr(buf_node, i);
inc_block_ref(trans, root, blocknr);
}
return 0;
@ -108,9 +109,10 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, struct
int i;
while(1) {
ret = radix_tree_gang_lookup(&root->fs_info->pinned_radix,
ret = radix_tree_gang_lookup_tag(&root->fs_info->pinned_radix,
(void **)gang, 0,
ARRAY_SIZE(gang));
ARRAY_SIZE(gang),
CTREE_EXTENT_PINNED);
if (!ret)
break;
if (!first)
@ -137,7 +139,7 @@ static int finish_current_insert(struct btrfs_trans_handle *trans, struct
btrfs_set_extent_refs(&extent_item, 1);
btrfs_set_extent_owner(&extent_item,
btrfs_header_parentid(&extent_root->node->node.header));
btrfs_header_parentid(btrfs_buffer_header(extent_root->node)));
ins.offset = 1;
ins.flags = 0;
btrfs_set_key_type(&ins, BTRFS_EXTENT_ITEM_KEY);
@ -156,11 +158,24 @@ static int finish_current_insert(struct btrfs_trans_handle *trans, struct
return 0;
}
static int pin_down_block(struct btrfs_root *root, u64 blocknr, int tag)
{
int err;
err = radix_tree_insert(&root->fs_info->pinned_radix,
blocknr, (void *)blocknr);
BUG_ON(err);
if (err)
return err;
radix_tree_tag_set(&root->fs_info->pinned_radix, blocknr,
tag);
return 0;
}
/*
* remove an extent from the root, returns 0 on success
*/
static int __free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
*root, u64 blocknr, u64 num_blocks, int pin)
*root, u64 blocknr, u64 num_blocks)
{
struct btrfs_path path;
struct btrfs_key key;
@ -171,7 +186,6 @@ static int __free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
struct btrfs_key ins;
u32 refs;
BUG_ON(pin && num_blocks != 1);
key.objectid = blocknr;
key.flags = 0;
btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
@ -186,26 +200,18 @@ static int __free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
printk("failed to find %Lu\n", key.objectid);
BUG();
}
ei = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
ei = btrfs_item_ptr(btrfs_buffer_leaf(path.nodes[0]), path.slots[0],
struct btrfs_extent_item);
BUG_ON(ei->refs == 0);
refs = btrfs_extent_refs(ei) - 1;
btrfs_set_extent_refs(ei, refs);
if (refs == 0) {
u64 super_blocks_used;
if (pin) {
int err;
radix_tree_preload(GFP_KERNEL);
err = radix_tree_insert(&info->pinned_radix,
blocknr, (void *)blocknr);
BUG_ON(err);
radix_tree_preload_end();
}
super_blocks_used = btrfs_super_blocks_used(info->disk_super);
btrfs_set_super_blocks_used(info->disk_super,
super_blocks_used - num_blocks);
ret = btrfs_del_item(trans, extent_root, &path);
if (!pin && extent_root->fs_info->last_insert.objectid >
if (extent_root->fs_info->last_insert.objectid >
blocknr)
extent_root->fs_info->last_insert.objectid = blocknr;
if (ret)
@ -224,39 +230,32 @@ static int del_pending_extents(struct btrfs_trans_handle *trans, struct
btrfs_root *extent_root)
{
int ret;
struct btrfs_buffer *gang[4];
int wret;
int err = 0;
unsigned long gang[4];
int i;
struct radix_tree_root *radix = &extent_root->fs_info->pinned_radix;
while(1) {
ret = radix_tree_gang_lookup_tag(
&extent_root->fs_info->cache_radix,
&extent_root->fs_info->pinned_radix,
(void **)gang, 0,
ARRAY_SIZE(gang),
CTREE_EXTENT_PENDING_DEL);
if (!ret)
break;
for (i = 0; i < ret; i++) {
ret = __free_extent(trans, extent_root,
gang[i]->blocknr, 1, 1);
radix_tree_tag_clear(&extent_root->fs_info->cache_radix,
gang[i]->blocknr,
radix_tree_tag_set(radix, gang[i], CTREE_EXTENT_PINNED);
radix_tree_tag_clear(radix, gang[i],
CTREE_EXTENT_PENDING_DEL);
btrfs_block_release(extent_root, gang[i]);
wret = __free_extent(trans, extent_root, gang[i], 1);
if (wret)
err = wret;
}
}
return 0;
return err;
}
static int run_pending(struct btrfs_trans_handle *trans, struct btrfs_root
*extent_root)
{
while(radix_tree_tagged(&extent_root->fs_info->cache_radix,
CTREE_EXTENT_PENDING_DEL))
del_pending_extents(trans, extent_root);
return 0;
}
/*
* remove an extent from the root, returns 0 on success
*/
@ -264,18 +263,21 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
*root, u64 blocknr, u64 num_blocks, int pin)
{
struct btrfs_root *extent_root = root->fs_info->extent_root;
struct btrfs_buffer *t;
struct buffer_head *t;
int pending_ret;
int ret;
if (root == extent_root) {
t = find_tree_block(root, blocknr);
radix_tree_tag_set(&root->fs_info->cache_radix, blocknr,
CTREE_EXTENT_PENDING_DEL);
pin_down_block(root, blocknr, CTREE_EXTENT_PENDING_DEL);
return 0;
}
ret = __free_extent(trans, root, blocknr, num_blocks, pin);
pending_ret = run_pending(trans, root->fs_info->extent_root);
if (pin) {
ret = pin_down_block(root, blocknr, CTREE_EXTENT_PINNED);
BUG_ON(ret);
}
ret = __free_extent(trans, root, blocknr, num_blocks);
pending_ret = del_pending_extents(trans, root->fs_info->extent_root);
return ret ? ret : pending_ret;
}
@ -296,14 +298,16 @@ static int find_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
int ret;
u64 hole_size = 0;
int slot = 0;
u64 last_block;
u64 last_block = 0;
u64 test_block;
int start_found;
struct btrfs_leaf *l;
struct btrfs_root * root = orig_root->fs_info->extent_root;
int total_needed = num_blocks;
int level;
total_needed += (btrfs_header_level(&root->node->node.header) + 1) * 3;
level = btrfs_header_level(btrfs_buffer_header(root->node));
total_needed += (level + 1) * 3;
if (root->fs_info->last_insert.objectid > search_start)
search_start = root->fs_info->last_insert.objectid;
@ -323,7 +327,7 @@ check_failed:
path.slots[0]--;
while (1) {
l = &path.nodes[0]->leaf;
l = btrfs_buffer_leaf(path.nodes[0]);
slot = path.slots[0];
if (slot >= btrfs_header_nritems(&l->header)) {
ret = btrfs_next_leaf(root, &path);
@ -429,7 +433,7 @@ static int alloc_extent(struct btrfs_trans_handle *trans, struct btrfs_root
sizeof(extent_item));
finish_current_insert(trans, extent_root);
pending_ret = run_pending(trans, extent_root);
pending_ret = del_pending_extents(trans, extent_root);
if (ret)
return ret;
if (pending_ret)
@ -441,16 +445,15 @@ static int alloc_extent(struct btrfs_trans_handle *trans, struct btrfs_root
* helper function to allocate a block for a given tree
* returns the tree buffer or NULL.
*/
struct btrfs_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
struct buffer_head *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
struct btrfs_root *root)
{
struct btrfs_key ins;
int ret;
struct btrfs_buffer *buf;
struct buffer_head *buf;
ret = alloc_extent(trans, root, 1, 0, (unsigned long)-1,
btrfs_header_parentid(&root->node->node.header),
&ins);
btrfs_header_parentid(btrfs_buffer_header(root->node)), &ins);
if (ret) {
BUG();
return NULL;
@ -467,13 +470,13 @@ struct btrfs_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
static int walk_down_tree(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_path *path, int *level)
{
struct btrfs_buffer *next;
struct btrfs_buffer *cur;
struct buffer_head *next;
struct buffer_head *cur;
u64 blocknr;
int ret;
u32 refs;
ret = lookup_block_ref(trans, root, path->nodes[*level]->blocknr,
ret = lookup_block_ref(trans, root, path->nodes[*level]->b_blocknr,
&refs);
BUG_ON(ret);
if (refs > 1)
@ -484,9 +487,10 @@ static int walk_down_tree(struct btrfs_trans_handle *trans, struct btrfs_root
while(*level > 0) {
cur = path->nodes[*level];
if (path->slots[*level] >=
btrfs_header_nritems(&cur->node.header))
btrfs_header_nritems(btrfs_buffer_header(cur)))
break;
blocknr = btrfs_node_blockptr(&cur->node, path->slots[*level]);
blocknr = btrfs_node_blockptr(btrfs_buffer_node(cur),
path->slots[*level]);
ret = lookup_block_ref(trans, root, blocknr, &refs);
if (refs != 1 || *level == 1) {
path->slots[*level]++;
@ -499,12 +503,12 @@ static int walk_down_tree(struct btrfs_trans_handle *trans, struct btrfs_root
if (path->nodes[*level-1])
btrfs_block_release(root, path->nodes[*level-1]);
path->nodes[*level-1] = next;
*level = btrfs_header_level(&next->node.header);
*level = btrfs_header_level(btrfs_buffer_header(next));
path->slots[*level] = 0;
}
out:
ret = btrfs_free_extent(trans, root, path->nodes[*level]->blocknr, 1,
1);
ret = btrfs_free_extent(trans, root, path->nodes[*level]->b_blocknr,
1, 1);
btrfs_block_release(root, path->nodes[*level]);
path->nodes[*level] = NULL;
*level += 1;
@ -525,14 +529,14 @@ static int walk_up_tree(struct btrfs_trans_handle *trans, struct btrfs_root
int ret;
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) {
if (slot < btrfs_header_nritems(
btrfs_buffer_header(path->nodes[i])) - 1) {
path->slots[i]++;
*level = i;
return 0;
} else {
ret = btrfs_free_extent(trans, root,
path->nodes[*level]->blocknr,
path->nodes[*level]->b_blocknr,
1, 1);
btrfs_block_release(root, path->nodes[*level]);
path->nodes[*level] = NULL;
@ -549,7 +553,7 @@ static int walk_up_tree(struct btrfs_trans_handle *trans, struct btrfs_root
* decremented.
*/
int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_buffer *snap)
*root, struct buffer_head *snap)
{
int ret = 0;
int wret;
@ -560,7 +564,7 @@ int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
btrfs_init_path(&path);
level = btrfs_header_level(&snap->node.header);
level = btrfs_header_level(btrfs_buffer_header(snap));
orig_level = level;
path.nodes[level] = snap;
path.slots[level] = 0;

9
fs/btrfs/hash.c
Просмотреть файл

@ -10,6 +10,7 @@
* License.
*/
#include <linux/types.h>
#define DELTA 0x9E3779B9
static void TEA_transform(__u32 buf[2], __u32 const in[])
@ -63,6 +64,14 @@ int btrfs_name_hash(const char *name, int len, u64 *hash_result)
const char *p;
__u32 in[8], buf[2];
if (len == 1 && *name == '.') {
*hash_result = 1;
return 0;
} else if (len == 2 && name[0] == '.' && name[1] == '.') {
*hash_result = 2;
return 0;
}
/* Initialize the default seed for the hash checksum functions */
buf[0] = 0x67452301;
buf[1] = 0xefcdab89;

8
fs/btrfs/inode-map.c
Просмотреть файл

@ -15,7 +15,7 @@ int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
int ret;
u64 hole_size = 0;
int slot = 0;
u64 last_ino;
u64 last_ino = 0;
int start_found;
struct btrfs_leaf *l;
struct btrfs_root *root = fs_root->fs_info->inode_root;
@ -40,7 +40,7 @@ int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
path.slots[0]--;
while (1) {
l = &path.nodes[0]->leaf;
l = btrfs_buffer_leaf(path.nodes[0]);
slot = path.slots[0];
if (slot >= btrfs_header_nritems(&l->header)) {
ret = btrfs_next_leaf(root, &path);
@ -105,8 +105,8 @@ int btrfs_insert_inode_map(struct btrfs_trans_handle *trans,
if (ret)
goto out;
inode_item = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
struct btrfs_inode_map_item);
inode_item = btrfs_item_ptr(btrfs_buffer_leaf(path.nodes[0]),
path.slots[0], struct btrfs_inode_map_item);
btrfs_cpu_key_to_disk(&inode_item->key, location);
out:
btrfs_release_path(inode_root, &path);

20
fs/btrfs/print-tree.c
Просмотреть файл

@ -17,7 +17,6 @@ void btrfs_print_leaf(struct btrfs_root *root, struct btrfs_leaf *l)
printk("leaf %Lu total ptrs %d free space %d\n",
btrfs_header_blocknr(&l->header), nr,
btrfs_leaf_free_space(root, l));
fflush(stdout);
for (i = 0 ; i < nr ; i++) {
item = l->items + i;
type = btrfs_disk_key_type(&item->key);
@ -67,10 +66,10 @@ void btrfs_print_leaf(struct btrfs_root *root, struct btrfs_leaf *l)
btrfs_leaf_data(l) + btrfs_item_offset(item));
break;
};
fflush(stdout);
}
}
void btrfs_print_tree(struct btrfs_root *root, struct btrfs_buffer *t)
void btrfs_print_tree(struct btrfs_root *root, struct buffer_head *t)
{
int i;
u32 nr;
@ -78,16 +77,16 @@ void btrfs_print_tree(struct btrfs_root *root, struct btrfs_buffer *t)
if (!t)
return;
c = &t->node;
c = btrfs_buffer_node(t);
nr = btrfs_header_nritems(&c->header);
if (btrfs_is_leaf(c)) {
btrfs_print_leaf(root, (struct btrfs_leaf *)c);
return;
}
printk("node %Lu level %d total ptrs %d free spc %u\n", t->blocknr,
btrfs_header_level(&c->header), nr,
(u32)BTRFS_NODEPTRS_PER_BLOCK(root) - nr);
fflush(stdout);
printk("node %Lu level %d total ptrs %d free spc %u\n",
btrfs_header_blocknr(&c->header),
btrfs_header_level(&c->header), nr,
(u32)BTRFS_NODEPTRS_PER_BLOCK(root) - nr);
for (i = 0; i < nr; i++) {
printk("\tkey %d (%Lu %u %Lu) block %Lu\n",
i,
@ -95,12 +94,11 @@ void btrfs_print_tree(struct btrfs_root *root, struct btrfs_buffer *t)
c->ptrs[i].key.flags,
c->ptrs[i].key.offset,
btrfs_node_blockptr(c, i));
fflush(stdout);
}
for (i = 0; i < nr; i++) {
struct btrfs_buffer *next_buf = read_tree_block(root,
struct buffer_head *next_buf = read_tree_block(root,
btrfs_node_blockptr(c, i));
struct btrfs_node *next = &next_buf->node;
struct btrfs_node *next = btrfs_buffer_node(next_buf);
if (btrfs_is_leaf(next) &&
btrfs_header_level(&c->header) != 1)
BUG();

2
fs/btrfs/print-tree.h
Просмотреть файл

@ -1,5 +1,5 @@
#ifndef __PRINT_TREE_
#define __PRINT_TREE_
void btrfs_print_leaf(struct btrfs_root *root, struct btrfs_leaf *l);
void btrfs_print_tree(struct btrfs_root *root, struct btrfs_buffer *t);
void btrfs_print_tree(struct btrfs_root *root, struct buffer_head *t);
#endif

4
fs/btrfs/root-tree.c
Просмотреть файл

@ -21,7 +21,7 @@ int btrfs_find_last_root(struct btrfs_root *root, u64 objectid,
if (ret < 0)
goto out;
BUG_ON(ret == 0);
l = &path.nodes[0]->leaf;
l = btrfs_buffer_leaf(path.nodes[0]);
BUG_ON(path.slots[0] == 0);
slot = path.slots[0] - 1;
if (btrfs_disk_key_objectid(&l->items[slot].key) != objectid) {
@ -51,7 +51,7 @@ int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
if (ret < 0)
goto out;
BUG_ON(ret != 0);
l = &path.nodes[0]->leaf;
l = btrfs_buffer_leaf(path.nodes[0]);
slot = path.slots[0];
memcpy(btrfs_item_ptr(l, slot, struct btrfs_root_item), item,
sizeof(*item));

263
fs/btrfs/super.c
Просмотреть файл

@ -1,4 +1,5 @@
#include <linux/module.h>
#include <linux/buffer_head.h>
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/highmem.h>
@ -8,13 +9,18 @@
#include <linux/smp_lock.h>
#include <linux/backing-dev.h>
#include "ctree.h"
#include "disk-io.h"
#define BTRFS_SUPER_MAGIC 0x9123682E
static struct inode_operations btrfs_dir_inode_operations;
static struct super_operations btrfs_super_ops;
static struct file_operations btrfs_dir_file_operations;
#if 0
/* some random number */
static struct super_operations ramfs_ops;
static struct inode_operations ramfs_dir_inode_operations;
static struct backing_dev_info ramfs_backing_dev_info = {
.ra_pages = 0, /* No readahead */
@ -129,46 +135,243 @@ static struct inode_operations ramfs_dir_inode_operations = {
};
#endif
struct inode *btrfs_get_inode(struct super_block *sb, int mode, dev_t dev)
static void btrfs_read_locked_inode(struct inode *inode)
{
struct inode * inode = new_inode(sb);
if (inode) {
inode->i_mode = mode;
inode->i_uid = current->fsuid;
inode->i_gid = current->fsgid;
inode->i_blocks = 0;
inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
struct btrfs_path path;
struct btrfs_inode_item *inode_item;
struct btrfs_root *root = btrfs_sb(inode->i_sb);
int ret;
printk("read locked inode %lu\n", inode->i_ino);
btrfs_init_path(&path);
ret = btrfs_lookup_inode(NULL, root, &path, inode->i_ino, 0);
if (ret) {
make_bad_inode(inode);
return;
}
return inode;
inode_item = btrfs_item_ptr(btrfs_buffer_leaf(path.nodes[0]),
path.slots[0],
struct btrfs_inode_item);
printk("found locked inode %lu\n", inode->i_ino);
inode->i_mode = btrfs_inode_mode(inode_item);
inode->i_nlink = btrfs_inode_nlink(inode_item);
inode->i_uid = btrfs_inode_uid(inode_item);
inode->i_gid = btrfs_inode_gid(inode_item);
inode->i_size = btrfs_inode_size(inode_item);
inode->i_atime.tv_sec = btrfs_timespec_sec(&inode_item->atime);
inode->i_atime.tv_nsec = btrfs_timespec_nsec(&inode_item->atime);
inode->i_mtime.tv_sec = btrfs_timespec_sec(&inode_item->mtime);
inode->i_mtime.tv_nsec = btrfs_timespec_nsec(&inode_item->mtime);
inode->i_ctime.tv_sec = btrfs_timespec_sec(&inode_item->ctime);
inode->i_ctime.tv_nsec = btrfs_timespec_nsec(&inode_item->ctime);
inode->i_blocks = btrfs_inode_nblocks(inode_item);
inode->i_generation = btrfs_inode_generation(inode_item);
printk("about to release\n");
btrfs_release_path(root, &path);
switch (inode->i_mode & S_IFMT) {
#if 0
default:
init_special_inode(inode, inode->i_mode,
btrfs_inode_rdev(inode_item));
break;
#endif
case S_IFREG:
printk("inode %lu now a file\n", inode->i_ino);
break;
case S_IFDIR:
printk("inode %lu now a directory\n", inode->i_ino);
inode->i_op = &btrfs_dir_inode_operations;
inode->i_fop = &btrfs_dir_file_operations;
break;
case S_IFLNK:
printk("inode %lu now a link\n", inode->i_ino);
// inode->i_op = &page_symlink_inode_operations;
break;
}
printk("returning!\n");
return;
}
static struct super_operations btrfs_ops = {
.statfs = simple_statfs,
.drop_inode = generic_delete_inode,
};
static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
ino_t *ino)
{
const char *name = dentry->d_name.name;
int namelen = dentry->d_name.len;
struct btrfs_dir_item *di;
struct btrfs_path path;
struct btrfs_root *root = btrfs_sb(dir->i_sb);
int ret;
btrfs_init_path(&path);
ret = btrfs_lookup_dir_item(NULL, root, &path, dir->i_ino, name,
namelen, 0);
if (ret) {
*ino = 0;
goto out;
}
di = btrfs_item_ptr(btrfs_buffer_leaf(path.nodes[0]), path.slots[0],
struct btrfs_dir_item);
*ino = btrfs_dir_objectid(di);
out:
btrfs_release_path(root, &path);
return ret;
}
static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
struct nameidata *nd)
{
struct inode * inode;
ino_t ino;
int ret;
if (dentry->d_name.len > BTRFS_NAME_LEN)
return ERR_PTR(-ENAMETOOLONG);
ret = btrfs_inode_by_name(dir, dentry, &ino);
if (ret < 0)
return ERR_PTR(ret);
inode = NULL;
if (ino) {
printk("lookup on %.*s returns %lu\n", dentry->d_name.len, dentry->d_name.name, ino);
inode = iget(dir->i_sb, ino);
if (!inode)
return ERR_PTR(-EACCES);
}
return d_splice_alias(inode, dentry);
}
static int btrfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
struct inode *inode = filp->f_path.dentry->d_inode;
struct btrfs_root *root = btrfs_sb(inode->i_sb);
struct btrfs_item *item;
struct btrfs_dir_item *di;
struct btrfs_key key;
struct btrfs_path path;
int ret;
u32 nritems;
struct btrfs_leaf *leaf;
int slot;
int advance;
unsigned char d_type = DT_UNKNOWN;
int over;
key.objectid = inode->i_ino;
printk("readdir on dir %Lu pos %Lu\n", key.objectid, filp->f_pos);
key.flags = 0;
btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
key.offset = filp->f_pos;
btrfs_init_path(&path);
ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
if (ret < 0) {
goto err;
}
printk("first ret %d\n", ret);
advance = filp->f_pos > 0 && ret != 0;
while(1) {
leaf = btrfs_buffer_leaf(path.nodes[0]);
nritems = btrfs_header_nritems(&leaf->header);
slot = path.slots[0];
printk("leaf %Lu nritems %lu slot %d\n", path.nodes[0]->b_blocknr, nritems, slot);
if (advance) {
printk("advancing!\n");
if (slot == nritems -1) {
ret = btrfs_next_leaf(root, &path);
if (ret)
break;
leaf = btrfs_buffer_leaf(path.nodes[0]);
nritems = btrfs_header_nritems(&leaf->header);
slot = path.slots[0];
printk("2leaf %Lu nritems %lu slot %d\n", path.nodes[0]->b_blocknr, nritems, slot);
} else {
slot++;
path.slots[0]++;
}
}
advance = 1;
item = leaf->items + slot;
printk("item key %Lu %u %Lu\n", btrfs_disk_key_objectid(&item->key),
btrfs_disk_key_flags(&item->key), btrfs_disk_key_offset(&item->key));
if (btrfs_disk_key_objectid(&item->key) != key.objectid)
break;
if (btrfs_disk_key_type(&item->key) != BTRFS_DIR_ITEM_KEY)
continue;
di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
printk("filldir name %.*s, objectid %Lu\n", btrfs_dir_name_len(di),
(const char *)(di + 1), btrfs_dir_objectid(di));
over = filldir(dirent, (const char *)(di + 1),
btrfs_dir_name_len(di),
btrfs_disk_key_offset(&item->key),
btrfs_dir_objectid(di), d_type);
if (over)
break;
filp->f_pos = btrfs_disk_key_offset(&item->key) + 1;
}
printk("filldir all done\n");
ret = 0;
err:
btrfs_release_path(root, &path);
return ret;
}
static void btrfs_put_super (struct super_block * sb)
{
struct btrfs_root *root = btrfs_sb(sb);
int ret;
ret = close_ctree(root);
if (ret) {
printk("close ctree returns %d\n", ret);
}
sb->s_fs_info = NULL;
}
static int btrfs_fill_super(struct super_block * sb, void * data, int silent)
{
struct inode * inode;
struct dentry * root;
struct dentry * root_dentry;
struct btrfs_super_block *disk_super;
struct buffer_head *bh;
struct btrfs_root *root;
sb->s_maxbytes = MAX_LFS_FILESIZE;
sb->s_blocksize = PAGE_CACHE_SIZE;
sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
sb->s_magic = BTRFS_SUPER_MAGIC;
sb->s_op = &btrfs_ops;
sb->s_op = &btrfs_super_ops;
sb->s_time_gran = 1;
inode = btrfs_get_inode(sb, S_IFDIR | 0755, 0);
bh = sb_bread(sb, BTRFS_SUPER_INFO_OFFSET / sb->s_blocksize);
if (!bh) {
printk("btrfs: unable to read on disk super\n");
return -EIO;
}
disk_super = (struct btrfs_super_block *)bh->b_data;
root = open_ctree(sb, bh, disk_super);
sb->s_fs_info = root;
if (!root) {
printk("btrfs: open_ctree failed\n");
return -EIO;
}
printk("read in super total blocks %Lu root %Lu\n",
btrfs_super_total_blocks(disk_super),
btrfs_super_root_dir(disk_super));
inode = iget_locked(sb, btrfs_super_root_dir(disk_super));
if (!inode)
return -ENOMEM;
if (inode->i_state & I_NEW) {
btrfs_read_locked_inode(inode);
unlock_new_inode(inode);
}
root = d_alloc_root(inode);
if (!root) {
root_dentry = d_alloc_root(inode);
if (!root_dentry) {
iput(inode);
return -ENOMEM;
}
sb->s_root = root;
sb->s_root = root_dentry;
return 0;
}
@ -187,6 +390,24 @@ static struct file_system_type btrfs_fs_type = {
.fs_flags = FS_REQUIRES_DEV,
};
static struct super_operations btrfs_super_ops = {
.statfs = simple_statfs,
.drop_inode = generic_delete_inode,
.put_super = btrfs_put_super,
.read_inode = btrfs_read_locked_inode,
};
static struct inode_operations btrfs_dir_inode_operations = {
.lookup = btrfs_lookup,
};
static struct file_operations btrfs_dir_file_operations = {
.llseek = generic_file_llseek,
.read = generic_read_dir,
.readdir = btrfs_readdir,
};
static int __init init_btrfs_fs(void)
{
printk("btrfs loaded!\n");

4
fs/btrfs/transaction.h
Просмотреть файл

@ -10,7 +10,7 @@ struct btrfs_trans_handle {
static inline struct btrfs_trans_handle *
btrfs_start_transaction(struct btrfs_root *root, int num_blocks)
{
struct btrfs_trans_handle *h = malloc(sizeof(*h));
struct btrfs_trans_handle *h = kmalloc(sizeof(*h), GFP_NOFS);
h->transid = root->root_key.offset;
h->blocks_reserved = num_blocks;
h->blocks_used = 0;
@ -21,7 +21,7 @@ static inline void btrfs_free_transaction(struct btrfs_root *root,
struct btrfs_trans_handle *handle)
{
memset(handle, 0, sizeof(*handle));
free(handle);
kfree(handle);
}
#endif