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 != 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 ctree_root *root)
  27 {
  28         struct list_head *node, *next;
  29         struct tree_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 tree_buffer, cache);
  34                 if (b->count == 1) {
  35                         BUG_ON(!list_empty(&b->dirty));
  36                         list_del_init(&b->cache);
  37                         tree_block_release(root, b);
  38                         if (root->cache_size < cache_max)
  39                                 break;
  40                 }
  41         }
  42         return 0;
  43 }
  44
  45 struct tree_buffer *alloc_tree_block(struct ctree_root *root, u64 blocknr)
  46 {
  47         struct tree_buffer *buf;
  48         int ret;
  49         buf = malloc(sizeof(struct tree_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 tree_buffer *find_tree_block(struct ctree_root *root, u64 blocknr)
  70 {
  71         struct tree_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 tree_buffer *read_tree_block(struct ctree_root *root, u64 blocknr)
  86 {
  87         loff_t offset = blocknr * CTREE_BLOCKSIZE;
  88         struct tree_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, CTREE_BLOCKSIZE, offset);
  99                 if (ret != CTREE_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 ctree_root *root, struct tree_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 ctree_root *root, struct tree_buffer *buf)
 119 {
 120         if (!list_empty(&buf->dirty)) {
 121                 list_del_init(&buf->dirty);
 122                 tree_block_release(root, buf);
 123         }
 124         return 0;
 125 }
 126
 127 int write_tree_block(struct ctree_root *root, struct tree_buffer *buf)
 128 {
 129         u64 blocknr = buf->blocknr;
 130         loff_t offset = blocknr * CTREE_BLOCKSIZE;
 131         int ret;
 132
 133         if (buf->blocknr != btrfs_header_blocknr(&buf->node.header))
 134                 BUG();
 135         ret = pwrite(root->fp, &buf->node, CTREE_BLOCKSIZE, offset);
 136         if (ret != CTREE_BLOCKSIZE)
 137                 return ret;
 138         return 0;
 139 }
 140
 141 static int __commit_transaction(struct ctree_root *root)
 142 {
 143         struct tree_buffer *b;
 144         int ret = 0;
 145         int wret;
 146         while(!list_empty(&root->trans)) {
 147                 b = list_entry(root->trans.next, struct tree_buffer, dirty);
 148                 list_del_init(&b->dirty);
 149                 wret = write_tree_block(root, b);
 150                 if (wret)
 151                         ret = wret;
 152                 tree_block_release(root, b);
 153         }
 154         return ret;
 155 }
 156
 157 int commit_transaction(struct ctree_root *root, struct ctree_super_block *s)
 158 {
 159         int ret = 0;
 160
 161         ret = __commit_transaction(root);
 162         if (!ret && root != root->extent_root)
 163                 ret = __commit_transaction(root->extent_root);
 164         BUG_ON(ret);
 165         if (root->commit_root != root->node) {
 166                 struct tree_buffer *snap = root->commit_root;
 167                 root->commit_root = root->node;
 168                 root->node->count++;
 169                 ret = btrfs_drop_snapshot(root, snap);
 170                 BUG_ON(ret);
 171                 // tree_block_release(root, snap);
 172         }
 173         write_ctree_super(root, s);
 174         btrfs_finish_extent_commit(root);
 175         return ret;
 176 }
 177
 178 static int __setup_root(struct ctree_root *root, struct ctree_root *extent_root,
 179                         struct ctree_root_info *info, int fp)
 180 {
 181         INIT_LIST_HEAD(&root->trans);
 182         INIT_LIST_HEAD(&root->cache);
 183         root->cache_size = 0;
 184         root->fp = fp;
 185         root->node = NULL;
 186         root->extent_root = extent_root;
 187         root->commit_root = NULL;
 188         root->node = read_tree_block(root, info->tree_root);
 189         memset(&root->current_insert, 0, sizeof(root->current_insert));
 190         memset(&root->last_insert, 0, sizeof(root->last_insert));
 191         return 0;
 192 }
 193
 194 struct ctree_root *open_ctree(char *filename, struct ctree_super_block *super)
 195 {
 196         struct ctree_root *root = malloc(sizeof(struct ctree_root));
 197         struct ctree_root *extent_root = malloc(sizeof(struct ctree_root));
 198         int fp;
 199         int ret;
 200
 201         fp = open(filename, O_CREAT | O_RDWR, 0600);
 202         if (fp < 0) {
 203                 free(root);
 204                 return NULL;
 205         }
 206         INIT_RADIX_TREE(&root->cache_radix, GFP_KERNEL);
 207         INIT_RADIX_TREE(&root->pinned_radix, GFP_KERNEL);
 208         INIT_RADIX_TREE(&extent_root->pinned_radix, GFP_KERNEL);
 209         INIT_RADIX_TREE(&extent_root->cache_radix, GFP_KERNEL);
 210         ret = pread(fp, super, sizeof(struct ctree_super_block),
 211                      CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
 212         if (ret == 0 || super->root_info.tree_root == 0) {
 213                 printf("making new FS!\n");
 214                 ret = mkfs(fp);
 215                 if (ret)
 216                         return NULL;
 217                 ret = pread(fp, super, sizeof(struct ctree_super_block),
 218                              CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
 219                 if (ret != sizeof(struct ctree_super_block))
 220                         return NULL;
 221         }
 222         BUG_ON(ret < 0);
 223         __setup_root(root, extent_root, &super->root_info, fp);
 224         __setup_root(extent_root, extent_root, &super->extent_info, fp);
 225         root->commit_root = root->node;
 226         root->node->count++;
 227         return root;
 228 }
 229
 230 static int __update_root(struct ctree_root *root, struct ctree_root_info *info)
 231 {
 232         info->tree_root = root->node->blocknr;
 233         return 0;
 234 }
 235
 236 int write_ctree_super(struct ctree_root *root, struct ctree_super_block *s)
 237 {
 238         int ret;
 239         __update_root(root, &s->root_info);
 240         __update_root(root->extent_root, &s->extent_info);
 241         ret = pwrite(root->fp, s, sizeof(*s), CTREE_SUPER_INFO_OFFSET(CTREE_BLOCKSIZE));
 242         if (ret != sizeof(*s)) {
 243                 fprintf(stderr, "failed to write new super block err %d\n", ret);
 244                 return ret;
 245         }
 246         return 0;
 247 }
 248
 249 static int drop_cache(struct ctree_root *root)
 250 {
 251         while(!list_empty(&root->cache)) {
 252                 struct tree_buffer *b = list_entry(root->cache.next,
 253                                                    struct tree_buffer, cache);
 254                 list_del_init(&b->cache);
 255                 tree_block_release(root, b);
 256         }
 257         return 0;
 258 }
 259 int close_ctree(struct ctree_root *root, struct ctree_super_block *s)
 260 {
 261         commit_transaction(root, s);
 262         __commit_transaction(root->extent_root);
 263         write_ctree_super(root, s);
 264         drop_cache(root->extent_root);
 265         drop_cache(root);
 266         BUG_ON(!list_empty(&root->trans));
 267         BUG_ON(!list_empty(&root->extent_root->trans));
 268
 269         close(root->fp);
 270         if (root->node)
 271                 tree_block_release(root, root->node);
 272         if (root->extent_root->node)
 273                 tree_block_release(root->extent_root, root->extent_root->node);
 274         tree_block_release(root, root->commit_root);
 275         free(root);
 276         printf("on close %d blocks are allocated\n", allocated_blocks);
 277         return 0;
 278 }
 279
 280 void tree_block_release(struct ctree_root *root, struct tree_buffer *buf)
 281 {
 282         buf->count--;
 283         if (buf->count < 0)
 284                 BUG();
 285         if (buf->count == 0) {
 286                 BUG_ON(!list_empty(&buf->cache));
 287                 BUG_ON(!list_empty(&buf->dirty));
 288                 if (!radix_tree_lookup(&root->cache_radix, buf->blocknr))
 289                         BUG();
 290                 radix_tree_delete(&root->cache_radix, buf->blocknr);
 291                 memset(buf, 0, sizeof(*buf));
 292                 free(buf);
 293                 BUG_ON(allocated_blocks == 0);
 294                 allocated_blocks--;
 295                 BUG_ON(root->cache_size == 0);
 296                 root->cache_size--;
 297         }
 298 }
 299