1 #define _XOPEN_SOURCE 500
8 #include "kerncompat.h"
9 #include "radix-tree.h"
13 static int allocated_blocks = 0;
14 int cache_max = 10000;
16 static int check_tree_block(struct ctree_root *root, struct tree_buffer *buf)
18 if (buf->blocknr != buf->node.header.blocknr)
20 if (root->node && buf->node.header.parentid != root->node->node.header.parentid)
25 static int free_some_buffers(struct ctree_root *root)
27 struct list_head *node, *next;
28 struct tree_buffer *b;
29 if (root->cache_size < cache_max)
31 list_for_each_safe(node, next, &root->cache) {
32 b = list_entry(node, struct tree_buffer, cache);
34 BUG_ON(!list_empty(&b->dirty));
35 list_del_init(&b->cache);
36 tree_block_release(root, b);
37 if (root->cache_size < cache_max)
44 struct tree_buffer *alloc_tree_block(struct ctree_root *root, u64 blocknr)
46 struct tree_buffer *buf;
48 buf = malloc(sizeof(struct tree_buffer));
52 buf->blocknr = blocknr;
54 INIT_LIST_HEAD(&buf->dirty);
55 free_some_buffers(root);
56 radix_tree_preload(GFP_KERNEL);
57 ret = radix_tree_insert(&root->cache_radix, blocknr, buf);
58 radix_tree_preload_end();
59 list_add_tail(&buf->cache, &root->cache);
68 struct tree_buffer *find_tree_block(struct ctree_root *root, u64 blocknr)
70 struct tree_buffer *buf;
71 buf = radix_tree_lookup(&root->cache_radix, blocknr);
75 buf = alloc_tree_block(root, blocknr);
84 struct tree_buffer *read_tree_block(struct ctree_root *root, u64 blocknr)
86 loff_t offset = blocknr * CTREE_BLOCKSIZE;
87 struct tree_buffer *buf;
90 buf = radix_tree_lookup(&root->cache_radix, blocknr);
94 buf = alloc_tree_block(root, blocknr);
97 ret = pread(root->fp, &buf->node, CTREE_BLOCKSIZE, offset);
98 if (ret != CTREE_BLOCKSIZE) {
103 if (check_tree_block(root, buf))
108 int dirty_tree_block(struct ctree_root *root, struct tree_buffer *buf)
110 if (!list_empty(&buf->dirty))
112 list_add_tail(&buf->dirty, &root->trans);
117 int clean_tree_block(struct ctree_root *root, struct tree_buffer *buf)
119 if (!list_empty(&buf->dirty)) {
120 list_del_init(&buf->dirty);
121 tree_block_release(root, buf);
126 int write_tree_block(struct ctree_root *root, struct tree_buffer *buf)
128 u64 blocknr = buf->blocknr;
129 loff_t offset = blocknr * CTREE_BLOCKSIZE;
132 if (buf->blocknr != buf->node.header.blocknr)
134 ret = pwrite(root->fp, &buf->node, CTREE_BLOCKSIZE, offset);
135 if (ret != CTREE_BLOCKSIZE)
140 static int __commit_transaction(struct ctree_root *root)
142 struct tree_buffer *b;
145 while(!list_empty(&root->trans)) {
146 b = list_entry(root->trans.next, struct tree_buffer, dirty);
147 list_del_init(&b->dirty);
148 wret = write_tree_block(root, b);
151 tree_block_release(root, b);
156 int commit_transaction(struct ctree_root *root)
159 ret = __commit_transaction(root);
160 if (!ret && root != root->extent_root)
161 ret = __commit_transaction(root->extent_root);
166 static int __setup_root(struct ctree_root *root, struct ctree_root *extent_root,
167 struct ctree_root_info *info, int fp)
169 INIT_LIST_HEAD(&root->trans);
170 INIT_LIST_HEAD(&root->cache);
173 root->node = read_tree_block(root, info->tree_root);
174 root->extent_root = extent_root;
178 struct ctree_root *open_ctree(char *filename, struct ctree_super_block *super)
180 struct ctree_root *root = malloc(sizeof(struct ctree_root));
181 struct ctree_root *extent_root = malloc(sizeof(struct ctree_root));
185 fp = open(filename, O_CREAT | O_RDWR, 0600);
190 INIT_RADIX_TREE(&root->cache_radix, GFP_KERNEL);
191 INIT_RADIX_TREE(&extent_root->cache_radix, GFP_KERNEL);
192 ret = pread(fp, super, sizeof(struct ctree_super_block),
193 CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
194 if (ret == 0 || super->root_info.tree_root == 0) {
195 printf("making new FS!\n");
199 ret = pread(fp, super, sizeof(struct ctree_super_block),
200 CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
201 if (ret != sizeof(struct ctree_super_block))
205 __setup_root(root, extent_root, &super->root_info, fp);
206 __setup_root(extent_root, extent_root, &super->extent_info, fp);
210 static int __update_root(struct ctree_root *root, struct ctree_root_info *info)
212 info->tree_root = root->node->blocknr;
216 int write_ctree_super(struct ctree_root *root, struct ctree_super_block *s)
219 __update_root(root, &s->root_info);
220 __update_root(root->extent_root, &s->extent_info);
221 ret = pwrite(root->fp, s, sizeof(*s), CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
222 if (ret != sizeof(*s)) {
223 fprintf(stderr, "failed to write new super block err %d\n", ret);
229 static int drop_cache(struct ctree_root *root)
231 while(!list_empty(&root->cache)) {
232 struct tree_buffer *b = list_entry(root->cache.next,
233 struct tree_buffer, cache);
234 list_del_init(&b->cache);
235 tree_block_release(root, b);
239 int close_ctree(struct ctree_root *root)
241 commit_transaction(root);
242 drop_cache(root->extent_root);
244 BUG_ON(!list_empty(&root->trans));
245 BUG_ON(!list_empty(&root->extent_root->trans));
249 tree_block_release(root, root->node);
250 if (root->extent_root->node)
251 tree_block_release(root->extent_root, root->extent_root->node);
253 printf("on close %d blocks are allocated\n", allocated_blocks);
257 void tree_block_release(struct ctree_root *root, struct tree_buffer *buf)
262 if (buf->count == 0) {
263 if (!radix_tree_lookup(&root->cache_radix, buf->blocknr))
265 radix_tree_delete(&root->cache_radix, buf->blocknr);
266 memset(buf, 0, sizeof(*buf));
268 BUG_ON(allocated_blocks == 0);
270 BUG_ON(root->cache_size == 0);