GitHub-Mirror/linux-bl808
2
0
Fork 0
mirror of https://github.com/Fishwaldo/linux-bl808.git synced 2025-06-17 20:25:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Btrfs: Add inode map, and the start of file extent items

Browse source 
Signed-off-by: Chris Mason <chris.mason@oracle.com>
This commit is contained in:
Chris Mason 2007-03-20 14:38:32 -04:00 • committed by David Woodhouse
parent 631d7d950a
commit 9f5fae2fe6
11 changed files with 541 additions and 172 deletions
Download patch file Download diff file Expand all files Collapse all files

174
fs/btrfs/disk-io.c
View file

@ -28,15 +28,15 @@ static int free_some_buffers(struct btrfs_root *root)
{
struct list_head *node, *next;
struct btrfs_buffer *b;
if (root->cache_size < cache_max)
if (root->fs_info->cache_size < cache_max)
return 0;
list_for_each_safe(node, next, &root->cache) {
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->cache_size < cache_max)
if (root->fs_info->cache_size < cache_max)
break;
}
}
@ -57,10 +57,10 @@ struct btrfs_buffer *alloc_tree_block(struct btrfs_root *root, u64 blocknr)
INIT_LIST_HEAD(&buf->dirty);
free_some_buffers(root);
radix_tree_preload(GFP_KERNEL);
ret = radix_tree_insert(&root->cache_radix, blocknr, buf);
ret = radix_tree_insert(&root->fs_info->cache_radix, blocknr, buf);
radix_tree_preload_end();
list_add_tail(&buf->cache, &root->cache);
root->cache_size++;
list_add_tail(&buf->cache, &root->fs_info->cache);
root->fs_info->cache_size++;
if (ret) {
free(buf);
return NULL;
@ -71,7 +71,7 @@ struct btrfs_buffer *alloc_tree_block(struct btrfs_root *root, u64 blocknr)
struct btrfs_buffer *find_tree_block(struct btrfs_root *root, u64 blocknr)
{
struct btrfs_buffer *buf;
buf = radix_tree_lookup(&root->cache_radix, blocknr);
buf = radix_tree_lookup(&root->fs_info->cache_radix, blocknr);
if (buf) {
buf->count++;
} else {
@ -90,14 +90,15 @@ struct btrfs_buffer *read_tree_block(struct btrfs_root *root, u64 blocknr)
struct btrfs_buffer *buf;
int ret;
buf = radix_tree_lookup(&root->cache_radix, blocknr);
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->fp, &buf->node, root->blocksize, offset);
ret = pread(root->fs_info->fp, &buf->node, root->blocksize,
offset);
if (ret != root->blocksize) {
free(buf);
return NULL;
@ -113,7 +114,7 @@ int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
{
if (!list_empty(&buf->dirty))
return 0;
list_add_tail(&buf->dirty, &root->trans);
list_add_tail(&buf->dirty, &root->fs_info->trans);
buf->count++;
return 0;
}
@ -137,7 +138,7 @@ int write_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
if (buf->blocknr != btrfs_header_blocknr(&buf->node.header))
BUG();
ret = pwrite(root->fp, &buf->node, root->blocksize, offset);
ret = pwrite(root->fs_info->fp, &buf->node, root->blocksize, offset);
if (ret != root->blocksize)
return ret;
return 0;
@ -149,8 +150,9 @@ static int __commit_transaction(struct btrfs_trans_handle *trans, struct
struct btrfs_buffer *b;
int ret = 0;
int wret;
while(!list_empty(&root->trans)) {
b = list_entry(root->trans.next, struct btrfs_buffer, dirty);
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)
@ -160,13 +162,21 @@ static int __commit_transaction(struct btrfs_trans_handle *trans, struct
return ret;
}
static int commit_extent_and_tree_roots(struct btrfs_trans_handle *trans,
struct btrfs_root *tree_root, struct
btrfs_root *extent_root)
static int commit_tree_roots(struct btrfs_trans_handle *trans,
struct btrfs_fs_info *fs_info)
{
int ret;
u64 old_extent_block;
struct btrfs_root *tree_root = fs_info->tree_root;
struct btrfs_root *extent_root = fs_info->extent_root;
struct btrfs_root *inode_root = fs_info->inode_root;
btrfs_set_root_blocknr(&inode_root->root_item,
inode_root->node->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)
@ -178,8 +188,6 @@ static int commit_extent_and_tree_roots(struct btrfs_trans_handle *trans,
&extent_root->root_item);
BUG_ON(ret);
}
__commit_transaction(trans, extent_root);
__commit_transaction(trans, tree_root);
return 0;
}
@ -190,9 +198,6 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct
struct btrfs_buffer *snap = root->commit_root;
struct btrfs_key snap_key;
ret = __commit_transaction(trans, root);
BUG_ON(ret);
if (root->commit_root == root->node)
return 0;
@ -200,54 +205,55 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct
root->root_key.offset++;
btrfs_set_root_blocknr(&root->root_item, root->node->blocknr);
ret = btrfs_insert_root(trans, root->tree_root, &root->root_key,
&root->root_item);
ret = btrfs_insert_root(trans, root->fs_info->tree_root,
&root->root_key, &root->root_item);
BUG_ON(ret);
ret = commit_extent_and_tree_roots(trans, root->tree_root,
root->extent_root);
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);
btrfs_finish_extent_commit(trans, root->extent_root);
btrfs_finish_extent_commit(trans, root->tree_root);
btrfs_finish_extent_commit(trans, root->fs_info->extent_root);
btrfs_finish_extent_commit(trans, root->fs_info->tree_root);
root->commit_root = root->node;
root->node->count++;
ret = btrfs_drop_snapshot(trans, root, snap);
BUG_ON(ret);
ret = btrfs_del_root(trans, root->tree_root, &snap_key);
ret = btrfs_del_root(trans, root->fs_info->tree_root, &snap_key);
BUG_ON(ret);
return ret;
}
static int __setup_root(struct btrfs_super_block *super,
struct btrfs_root *root, u64 objectid, int fp)
struct btrfs_root *root,
struct btrfs_fs_info *fs_info,
u64 objectid, int fp)
{
INIT_LIST_HEAD(&root->trans);
INIT_LIST_HEAD(&root->cache);
root->cache_size = 0;
root->fp = fp;
root->node = NULL;
root->commit_root = NULL;
root->blocksize = btrfs_super_blocksize(super);
root->ref_cows = 0;
memset(&root->current_insert, 0, sizeof(root->current_insert));
memset(&root->last_insert, 0, sizeof(root->last_insert));
root->fs_info = fs_info;
memset(&root->root_key, 0, sizeof(root->root_key));
memset(&root->root_item, 0, sizeof(root->root_item));
return 0;
}
static int find_and_setup_root(struct btrfs_super_block *super,
struct btrfs_root *tree_root, u64 objectid,
struct btrfs_root *tree_root,
struct btrfs_fs_info *fs_info,
u64 objectid,
struct btrfs_root *root, int fp)
{
int ret;
__setup_root(super, root, objectid, fp);
__setup_root(super, root, fs_info, objectid, fp);
ret = btrfs_find_last_root(tree_root, objectid,
&root->root_item, &root->root_key);
BUG_ON(ret);
@ -263,29 +269,31 @@ struct btrfs_root *open_ctree(char *filename, 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));
int fp;
int ret;
root->extent_root = extent_root;
root->tree_root = tree_root;
extent_root->extent_root = extent_root;
extent_root->tree_root = tree_root;
tree_root->extent_root = extent_root;
tree_root->tree_root = tree_root;
fp = open(filename, O_CREAT | O_RDWR, 0600);
if (fp < 0) {
free(root);
return NULL;
}
INIT_RADIX_TREE(&root->cache_radix, GFP_KERNEL);
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);
INIT_RADIX_TREE(&tree_root->pinned_radix, GFP_KERNEL);
INIT_RADIX_TREE(&tree_root->cache_radix, GFP_KERNEL);
INIT_RADIX_TREE(&fs_info->cache_radix, GFP_KERNEL);
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;
fs_info->extent_root = extent_root;
fs_info->inode_root = inode_root;
fs_info->last_inode_alloc = 0;
fs_info->last_inode_alloc_dirid = 0;
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);
@ -301,16 +309,20 @@ struct btrfs_root *open_ctree(char *filename, struct btrfs_super_block *super)
}
BUG_ON(ret < 0);
__setup_root(super, tree_root, BTRFS_ROOT_TREE_OBJECTID, fp);
__setup_root(super, tree_root, fs_info, BTRFS_ROOT_TREE_OBJECTID, fp);
tree_root->node = read_tree_block(tree_root, btrfs_super_root(super));
BUG_ON(!tree_root->node);
ret = find_and_setup_root(super, tree_root, BTRFS_EXTENT_TREE_OBJECTID,
extent_root, fp);
ret = find_and_setup_root(super, tree_root, fs_info,
BTRFS_EXTENT_TREE_OBJECTID, extent_root, fp);
BUG_ON(ret);
ret = find_and_setup_root(super, tree_root, BTRFS_FS_TREE_OBJECTID,
root, fp);
ret = find_and_setup_root(super, tree_root, fs_info,
BTRFS_INODE_MAP_OBJECTID, inode_root, fp);
BUG_ON(ret);
ret = find_and_setup_root(super, tree_root, fs_info,
BTRFS_FS_TREE_OBJECTID, root, fp);
BUG_ON(ret);
root->commit_root = root->node;
@ -323,8 +335,8 @@ int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
*root, struct btrfs_super_block *s)
{
int ret;
btrfs_set_super_root(s, root->tree_root->node->blocknr);
ret = pwrite(root->fp, s, sizeof(*s),
btrfs_set_super_root(s, root->fs_info->tree_root->node->blocknr);
ret = pwrite(root->fs_info->fp, s, sizeof(*s),
BTRFS_SUPER_INFO_OFFSET);
if (ret != sizeof(*s)) {
fprintf(stderr, "failed to write new super block err %d\n", ret);
@ -335,9 +347,10 @@ int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
static int drop_cache(struct btrfs_root *root)
{
while(!list_empty(&root->cache)) {
struct btrfs_buffer *b = list_entry(root->cache.next,
struct btrfs_buffer, cache);
while(!list_empty(&root->fs_info->cache)) {
struct btrfs_buffer *b = list_entry(root->fs_info->cache.next,
struct btrfs_buffer,
cache);
list_del_init(&b->cache);
btrfs_block_release(root, b);
}
@ -348,26 +361,28 @@ int close_ctree(struct btrfs_root *root, struct btrfs_super_block *s)
int ret;
struct btrfs_trans_handle *trans;
trans = root->running_transaction;
trans = root->fs_info->running_transaction;
btrfs_commit_transaction(trans, root, s);
ret = commit_extent_and_tree_roots(trans, root->tree_root,
root->extent_root);
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);
drop_cache(root->extent_root);
drop_cache(root->tree_root);
drop_cache(root);
BUG_ON(!list_empty(&root->trans));
BUG_ON(!list_empty(&root->extent_root->trans));
BUG_ON(!list_empty(&root->tree_root->trans));
BUG_ON(!list_empty(&root->fs_info->trans));
close(root->fp);
close(root->fs_info->fp);
if (root->node)
btrfs_block_release(root, root->node);
if (root->extent_root->node)
btrfs_block_release(root->extent_root, root->extent_root->node);
if (root->tree_root->node)
btrfs_block_release(root->tree_root, root->tree_root->node);
if (root->fs_info->extent_root->node)
btrfs_block_release(root->fs_info->extent_root,
root->fs_info->extent_root->node);
if (root->fs_info->inode_root->node)
btrfs_block_release(root->fs_info->inode_root,
root->fs_info->inode_root->node);
if (root->fs_info->tree_root->node)
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);
@ -382,15 +397,16 @@ void btrfs_block_release(struct btrfs_root *root, struct btrfs_buffer *buf)
if (buf->count == 0) {
BUG_ON(!list_empty(&buf->cache));
BUG_ON(!list_empty(&buf->dirty));
if (!radix_tree_lookup(&root->cache_radix, buf->blocknr))
if (!radix_tree_lookup(&root->fs_info->cache_radix,
buf->blocknr))
BUG();
radix_tree_delete(&root->cache_radix, buf->blocknr);
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->cache_size == 0);
root->cache_size--;
BUG_ON(root->fs_info->cache_size == 0);
root->fs_info->cache_size--;
}
}