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