fs/btrfs/disk-io.c

   1 #define _XOPEN_SOURCE 500
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <sys/types.h>
   5 #include <sys/stat.h>
   6 #include <fcntl.h>
   7 #include <unistd.h>
   8 #include "kerncompat.h"
   9 #include "radix-tree.h"
  10 #include "ctree.h"
  11 #include "disk-io.h"
  12
  13 static int allocated_blocks = 0;
  14 int cache_max = 10000;
  15
  16 static int check_tree_block(struct ctree_root *root, struct tree_buffer *buf)
  17 {
  18         if (buf->blocknr != buf->node.header.blocknr)
  19                 BUG();
  20         if (root->node && buf->node.header.parentid != root->node->node.header.parentid)
  21                 BUG();
  22         return 0;
  23 }
  24
  25 static int free_some_buffers(struct ctree_root *root)
  26 {
  27         struct list_head *node, *next;
  28         struct tree_buffer *b;
  29         if (root->cache_size < cache_max)
  30                 return 0;
  31         list_for_each_safe(node, next, &root->cache) {
  32                 b = list_entry(node, struct tree_buffer, cache);
  33                 if (b->count == 1) {
  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)
  38                                 break;
  39                 }
  40         }
  41         return 0;
  42 }
  43
  44 struct tree_buffer *alloc_tree_block(struct ctree_root *root, u64 blocknr)
  45 {
  46         struct tree_buffer *buf;
  47         int ret;
  48         buf = malloc(sizeof(struct tree_buffer));
  49         if (!buf)
  50                 return buf;
  51         allocated_blocks++;
  52         buf->blocknr = blocknr;
  53         buf->count = 2;
  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);
  60         root->cache_size++;
  61         if (ret) {
  62                 free(buf);
  63                 return NULL;
  64         }
  65         return buf;
  66 }
  67
  68 struct tree_buffer *find_tree_block(struct ctree_root *root, u64 blocknr)
  69 {
  70         struct tree_buffer *buf;
  71         buf = radix_tree_lookup(&root->cache_radix, blocknr);
  72         if (buf) {
  73                 buf->count++;
  74         } else {
  75                 buf = alloc_tree_block(root, blocknr);
  76                 if (!buf) {
  77                         BUG();
  78                         return NULL;
  79                 }
  80         }
  81         return buf;
  82 }
  83
  84 struct tree_buffer *read_tree_block(struct ctree_root *root, u64 blocknr)
  85 {
  86         loff_t offset = blocknr * CTREE_BLOCKSIZE;
  87         struct tree_buffer *buf;
  88         int ret;
  89
  90         buf = radix_tree_lookup(&root->cache_radix, blocknr);
  91         if (buf) {
  92                 buf->count++;
  93         } else {
  94                 buf = alloc_tree_block(root, blocknr);
  95                 if (!buf)
  96                         return NULL;
  97                 ret = pread(root->fp, &buf->node, CTREE_BLOCKSIZE, offset);
  98                 if (ret != CTREE_BLOCKSIZE) {
  99                         free(buf);
 100                         return NULL;
 101                 }
 102         }
 103         if (check_tree_block(root, buf))
 104                 BUG();
 105         return buf;
 106 }
 107
 108 int dirty_tree_block(struct ctree_root *root, struct tree_buffer *buf)
 109 {
 110         if (!list_empty(&buf->dirty))
 111                 return 0;
 112         list_add_tail(&buf->dirty, &root->trans);
 113         buf->count++;
 114         return 0;
 115 }
 116
 117 int clean_tree_block(struct ctree_root *root, struct tree_buffer *buf)
 118 {
 119         if (!list_empty(&buf->dirty)) {
 120                 list_del_init(&buf->dirty);
 121                 tree_block_release(root, buf);
 122         }
 123         return 0;
 124 }
 125
 126 int write_tree_block(struct ctree_root *root, struct tree_buffer *buf)
 127 {
 128         u64 blocknr = buf->blocknr;
 129         loff_t offset = blocknr * CTREE_BLOCKSIZE;
 130         int ret;
 131
 132         if (buf->blocknr != buf->node.header.blocknr)
 133                 BUG();
 134         ret = pwrite(root->fp, &buf->node, CTREE_BLOCKSIZE, offset);
 135         if (ret != CTREE_BLOCKSIZE)
 136                 return ret;
 137         return 0;
 138 }
 139
 140 static int __commit_transaction(struct ctree_root *root)
 141 {
 142         struct tree_buffer *b;
 143         int ret = 0;
 144         int wret;
 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);
 149                 if (wret)
 150                         ret = wret;
 151                 tree_block_release(root, b);
 152         }
 153         return ret;
 154 }
 155
 156 int commit_transaction(struct ctree_root *root, struct ctree_super_block *s)
 157 {
 158         int ret = 0;
 159
 160         ret = __commit_transaction(root);
 161         if (!ret && root != root->extent_root)
 162                 ret = __commit_transaction(root->extent_root);
 163         BUG_ON(ret);
 164         if (root->commit_root != root->node) {
 165                 struct tree_buffer *snap = root->commit_root;
 166                 root->commit_root = root->node;
 167                 root->node->count++;
 168                 ret = btrfs_drop_snapshot(root, snap);
 169                 BUG_ON(ret);
 170                 tree_block_release(root, snap);
 171         }
 172         write_ctree_super(root, s);
 173         btrfs_finish_extent_commit(root);
 174         return ret;
 175 }
 176
 177 static int __setup_root(struct ctree_root *root, struct ctree_root *extent_root,
 178                         struct ctree_root_info *info, int fp)
 179 {
 180         INIT_LIST_HEAD(&root->trans);
 181         INIT_LIST_HEAD(&root->cache);
 182         root->cache_size = 0;
 183         root->fp = fp;
 184         root->node = NULL;
 185         root->extent_root = extent_root;
 186         root->commit_root = NULL;
 187         root->node = read_tree_block(root, info->tree_root);
 188         memset(&root->current_insert, 0, sizeof(root->current_insert));
 189         memset(&root->last_insert, 0, sizeof(root->last_insert));
 190         return 0;
 191 }
 192
 193 struct ctree_root *open_ctree(char *filename, struct ctree_super_block *super)
 194 {
 195         struct ctree_root *root = malloc(sizeof(struct ctree_root));
 196         struct ctree_root *extent_root = malloc(sizeof(struct ctree_root));
 197         int fp;
 198         int ret;
 199
 200         fp = open(filename, O_CREAT | O_RDWR, 0600);
 201         if (fp < 0) {
 202                 free(root);
 203                 return NULL;
 204         }
 205         INIT_RADIX_TREE(&root->cache_radix, GFP_KERNEL);
 206         INIT_RADIX_TREE(&root->pinned_radix, GFP_KERNEL);
 207         INIT_RADIX_TREE(&extent_root->pinned_radix, GFP_KERNEL);
 208         INIT_RADIX_TREE(&extent_root->cache_radix, GFP_KERNEL);
 209         ret = pread(fp, super, sizeof(struct ctree_super_block),
 210                      CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
 211         if (ret == 0 || super->root_info.tree_root == 0) {
 212                 printf("making new FS!\n");
 213                 ret = mkfs(fp);
 214                 if (ret)
 215                         return NULL;
 216                 ret = pread(fp, super, sizeof(struct ctree_super_block),
 217                              CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
 218                 if (ret != sizeof(struct ctree_super_block))
 219                         return NULL;
 220         }
 221         BUG_ON(ret < 0);
 222         __setup_root(root, extent_root, &super->root_info, fp);
 223         __setup_root(extent_root, extent_root, &super->extent_info, fp);
 224         root->commit_root = root->node;
 225         root->node->count++;
 226         return root;
 227 }
 228
 229 static int __update_root(struct ctree_root *root, struct ctree_root_info *info)
 230 {
 231         info->tree_root = root->node->blocknr;
 232         return 0;
 233 }
 234
 235 int write_ctree_super(struct ctree_root *root, struct ctree_super_block *s)
 236 {
 237         int ret;
 238         __update_root(root, &s->root_info);
 239         __update_root(root->extent_root, &s->extent_info);
 240         ret = pwrite(root->fp, s, sizeof(*s), CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
 241         if (ret != sizeof(*s)) {
 242                 fprintf(stderr, "failed to write new super block err %d\n", ret);
 243                 return ret;
 244         }
 245         return 0;
 246 }
 247
 248 static int drop_cache(struct ctree_root *root)
 249 {
 250         while(!list_empty(&root->cache)) {
 251                 struct tree_buffer *b = list_entry(root->cache.next,
 252                                                    struct tree_buffer, cache);
 253                 list_del_init(&b->cache);
 254                 tree_block_release(root, b);
 255         }
 256         return 0;
 257 }
 258 int close_ctree(struct ctree_root *root, struct ctree_super_block *s)
 259 {
 260         commit_transaction(root, s);
 261         __commit_transaction(root->extent_root);
 262         write_ctree_super(root, s);
 263         drop_cache(root->extent_root);
 264         drop_cache(root);
 265         BUG_ON(!list_empty(&root->trans));
 266         BUG_ON(!list_empty(&root->extent_root->trans));
 267
 268         close(root->fp);
 269         if (root->node)
 270                 tree_block_release(root, root->node);
 271         if (root->extent_root->node)
 272                 tree_block_release(root->extent_root, root->extent_root->node);
 273         tree_block_release(root, root->commit_root);
 274         free(root);
 275         printf("on close %d blocks are allocated\n", allocated_blocks);
 276         return 0;
 277 }
 278
 279 void tree_block_release(struct ctree_root *root, struct tree_buffer *buf)
 280 {
 281         buf->count--;
 282         if (buf->count < 0)
 283                 BUG();
 284         if (buf->count == 0) {
 285                 BUG_ON(!list_empty(&buf->cache));
 286                 BUG_ON(!list_empty(&buf->dirty));
 287                 if (!radix_tree_lookup(&root->cache_radix, buf->blocknr))
 288                         BUG();
 289                 radix_tree_delete(&root->cache_radix, buf->blocknr);
 290                 memset(buf, 0, sizeof(*buf));
 291                 free(buf);
 292                 BUG_ON(allocated_blocks == 0);
 293                 allocated_blocks--;
 294                 BUG_ON(root->cache_size == 0);
 295                 root->cache_size--;
 296         }
 297 }
 298