#include "disk-io.h"
static int allocated_blocks = 0;
+int cache_size = 0;
+int cache_max = 10000;
-struct ctree_header {
- u64 root_block;
-} __attribute__ ((__packed__));
-
-static int get_free_block(struct ctree_root *root, u64 *block)
+static int check_tree_block(struct ctree_root *root, struct tree_buffer *buf)
{
- struct stat st;
- int ret;
+ if (buf->blocknr != buf->node.header.blocknr)
+ BUG();
+ if (root->node && buf->node.header.parentid != root->node->node.header.parentid)
+ BUG();
+ return 0;
+}
- st.st_size = 0;
- ret = fstat(root->fp, &st);
- if (st.st_size > sizeof(struct ctree_header)) {
- *block = (st.st_size -
- sizeof(struct ctree_header)) / CTREE_BLOCKSIZE;
- } else {
- *block = 0;
+static int free_some_buffers(struct ctree_root *root)
+{
+ struct list_head *node, *next;
+ struct tree_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);
+ if (b->count == 1) {
+ BUG_ON(!list_empty(&b->dirty));
+ list_del_init(&b->cache);
+ tree_block_release(root, b);
+ if (root->cache_size < cache_max)
+ return 0;
+ }
}
- ret = ftruncate(root->fp, sizeof(struct ctree_header) + (*block + 1) *
- CTREE_BLOCKSIZE);
- return ret;
+ return 0;
}
struct tree_buffer *alloc_tree_block(struct ctree_root *root, u64 blocknr)
return buf;
allocated_blocks++;
buf->blocknr = blocknr;
- buf->count = 1;
+ buf->count = 2;
+ INIT_LIST_HEAD(&buf->dirty);
+ free_some_buffers(root);
radix_tree_preload(GFP_KERNEL);
ret = radix_tree_insert(&root->cache_radix, blocknr, buf);
radix_tree_preload_end();
+ list_add_tail(&buf->cache, &root->cache);
+ root->cache_size++;
if (ret) {
free(buf);
return NULL;
return buf;
}
-struct tree_buffer *alloc_free_block(struct ctree_root *root)
+struct tree_buffer *find_tree_block(struct ctree_root *root, u64 blocknr)
{
- u64 free_block;
- int ret;
- struct tree_buffer * buf;
- ret = get_free_block(root, &free_block);
- if (ret) {
- BUG();
- return NULL;
+ struct tree_buffer *buf;
+ buf = radix_tree_lookup(&root->cache_radix, blocknr);
+ if (buf) {
+ buf->count++;
+ } else {
+ buf = alloc_tree_block(root, blocknr);
+ if (!buf) {
+ BUG();
+ return NULL;
+ }
}
- buf = alloc_tree_block(root, free_block);
- if (!buf)
- BUG();
return buf;
}
struct tree_buffer *read_tree_block(struct ctree_root *root, u64 blocknr)
{
- loff_t offset = blocknr * CTREE_BLOCKSIZE + sizeof(struct ctree_header);
+ loff_t offset = blocknr * CTREE_BLOCKSIZE;
struct tree_buffer *buf;
int ret;
buf = radix_tree_lookup(&root->cache_radix, blocknr);
if (buf) {
buf->count++;
- if (buf->blocknr != blocknr)
- BUG();
- if (buf->blocknr != buf->node.header.blocknr)
- BUG();
- return buf;
- }
- buf = alloc_tree_block(root, blocknr);
- if (!buf)
- return NULL;
- ret = pread(root->fp, &buf->node, CTREE_BLOCKSIZE, offset);
- if (ret != CTREE_BLOCKSIZE) {
- free(buf);
- return NULL;
+ } else {
+ buf = alloc_tree_block(root, blocknr);
+ if (!buf)
+ return NULL;
+ ret = pread(root->fp, &buf->node, CTREE_BLOCKSIZE, offset);
+ if (ret != CTREE_BLOCKSIZE) {
+ free(buf);
+ return NULL;
+ }
}
- if (buf->blocknr != buf->node.header.blocknr)
+ if (check_tree_block(root, buf))
BUG();
return buf;
}
+int dirty_tree_block(struct ctree_root *root, struct tree_buffer *buf)
+{
+ if (!list_empty(&buf->dirty))
+ return 0;
+ list_add_tail(&buf->dirty, &root->trans);
+ buf->count++;
+ return 0;
+}
+
+int clean_tree_block(struct ctree_root *root, struct tree_buffer *buf)
+{
+ if (!list_empty(&buf->dirty)) {
+ list_del_init(&buf->dirty);
+ tree_block_release(root, buf);
+ }
+ return 0;
+}
+
int write_tree_block(struct ctree_root *root, struct tree_buffer *buf)
{
u64 blocknr = buf->blocknr;
- loff_t offset = blocknr * CTREE_BLOCKSIZE + sizeof(struct ctree_header);
+ loff_t offset = blocknr * CTREE_BLOCKSIZE;
int ret;
if (buf->blocknr != buf->node.header.blocknr)
ret = pwrite(root->fp, &buf->node, CTREE_BLOCKSIZE, offset);
if (ret != CTREE_BLOCKSIZE)
return ret;
- if (buf == root->node)
- return update_root_block(root);
return 0;
}
-struct ctree_root *open_ctree(char *filename)
+static int __commit_transaction(struct ctree_root *root)
+{
+ struct tree_buffer *b;
+ int ret = 0;
+ int wret;
+ while(!list_empty(&root->trans)) {
+ b = list_entry(root->trans.next, struct tree_buffer, dirty);
+ list_del_init(&b->dirty);
+ wret = write_tree_block(root, b);
+ if (wret)
+ ret = wret;
+ tree_block_release(root, b);
+ }
+ return ret;
+}
+
+int commit_transaction(struct ctree_root *root)
+{
+ int ret;
+ ret = __commit_transaction(root);
+ if (!ret && root != root->extent_root)
+ ret = __commit_transaction(root->extent_root);
+ BUG_ON(ret);
+ return ret;
+}
+
+static int __setup_root(struct ctree_root *root, struct ctree_root *extent_root,
+ struct ctree_root_info *info, int fp)
+{
+ INIT_LIST_HEAD(&root->trans);
+ INIT_LIST_HEAD(&root->cache);
+ root->fp = fp;
+ root->node = NULL;
+ root->node = read_tree_block(root, info->tree_root);
+ root->extent_root = extent_root;
+ return 0;
+}
+
+struct ctree_root *open_ctree(char *filename, struct ctree_super_block *super)
{
struct ctree_root *root = malloc(sizeof(struct ctree_root));
+ struct ctree_root *extent_root = malloc(sizeof(struct ctree_root));
int fp;
- u64 root_block;
int ret;
- fp = open(filename, O_CREAT | O_RDWR);
+ fp = open(filename, O_CREAT | O_RDWR, 0600);
if (fp < 0) {
free(root);
return NULL;
}
- root->fp = fp;
INIT_RADIX_TREE(&root->cache_radix, GFP_KERNEL);
- ret = pread(fp, &root_block, sizeof(u64), 0);
- if (ret == sizeof(u64)) {
- printf("reading root node at block %lu\n", root_block);
- root->node = read_tree_block(root, root_block);
- } else
- root->node = NULL;
+ INIT_RADIX_TREE(&extent_root->cache_radix, GFP_KERNEL);
+ ret = pread(fp, super, sizeof(struct ctree_super_block),
+ CTREE_SUPER_INFO_OFFSET(CTREE_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))
+ return NULL;
+ }
+ BUG_ON(ret < 0);
+ __setup_root(root, extent_root, &super->root_info, fp);
+ __setup_root(extent_root, extent_root, &super->extent_info, fp);
return root;
}
-int close_ctree(struct ctree_root *root)
+static int __update_root(struct ctree_root *root, struct ctree_root_info *info)
{
- close(root->fp);
- if (root->node)
- tree_block_release(root, root->node);
- free(root);
- printf("on close %d blocks are allocated\n", allocated_blocks);
+ info->tree_root = root->node->blocknr;
return 0;
}
-int update_root_block(struct ctree_root *root)
+int write_ctree_super(struct ctree_root *root, struct ctree_super_block *s)
{
int ret;
- u64 root_block = root->node->blocknr;
-
- ret = pwrite(root->fp, &root_block, sizeof(u64), 0);
- if (ret != sizeof(u64))
+ __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));
+ if (ret != sizeof(*s)) {
+ fprintf(stderr, "failed to write new super block err %d\n", ret);
return ret;
+ }
+ return 0;
+}
+
+static int drop_cache(struct ctree_root *root)
+{
+ while(!list_empty(&root->cache)) {
+ struct tree_buffer *b = list_entry(root->cache.next,
+ struct tree_buffer, cache);
+ list_del_init(&b->cache);
+ tree_block_release(root, b);
+ }
+ return 0;
+}
+int close_ctree(struct ctree_root *root)
+{
+ commit_transaction(root);
+ drop_cache(root->extent_root);
+ drop_cache(root);
+ BUG_ON(!list_empty(&root->trans));
+ BUG_ON(!list_empty(&root->extent_root->trans));
+
+ close(root->fp);
+ if (root->node)
+ tree_block_release(root, root->node);
+ if (root->extent_root->node)
+ tree_block_release(root->extent_root, root->extent_root->node);
+ 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)
{
buf->count--;
+ if (buf->count < 0)
+ BUG();
if (buf->count == 0) {
if (!radix_tree_lookup(&root->cache_radix, buf->blocknr))
BUG();
free(buf);
BUG_ON(allocated_blocks == 0);
allocated_blocks--;
+ BUG_ON(root->cache_size == 0);
+ root->cache_size--;
}
}
projects / deliverable / linux.git / blobdiff