extent_io.c

   1
   2 /*
   3  * Copyright (C) 2007 Oracle.  All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public
   7  * License v2 as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public
  15  * License along with this program; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 021110-1307, USA.
  18  */
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <fcntl.h>
  24 #include <unistd.h>
  25 #include <stdbool.h>
  26 #include "kerncompat.h"
  27 #include "extent_io.h"
  28 #include "list.h"
  29 #include "ctree.h"
  30 #include "volumes.h"
  31 #include "utils.h"
  32 #include "internal.h"
  33
  34 void extent_io_tree_init(struct extent_io_tree *tree)
  35 {
  36         cache_tree_init(&tree->state);
  37         cache_tree_init(&tree->cache);
  38         INIT_LIST_HEAD(&tree->lru);
  39         tree->cache_size = 0;
  40         tree->max_cache_size = (u64)total_memory() / 4;
  41 }
  42
  43 void extent_io_tree_init_cache_max(struct extent_io_tree *tree,
  44                                    u64 max_cache_size)
  45 {
  46         extent_io_tree_init(tree);
  47         tree->max_cache_size = max_cache_size;
  48 }
  49
  50 static struct extent_state *alloc_extent_state(void)
  51 {
  52         struct extent_state *state;
  53
  54         state = malloc(sizeof(*state));
  55         if (!state)
  56                 return NULL;
  57         state->cache_node.objectid = 0;
  58         state->refs = 1;
  59         state->state = 0;
  60         state->xprivate = 0;
  61         return state;
  62 }
  63
  64 static void btrfs_free_extent_state(struct extent_state *state)
  65 {
  66         state->refs--;
  67         BUG_ON(state->refs < 0);
  68         if (state->refs == 0)
  69                 free(state);
  70 }
  71
  72 static void free_extent_state_func(struct cache_extent *cache)
  73 {
  74         struct extent_state *es;
  75
  76         es = container_of(cache, struct extent_state, cache_node);
  77         btrfs_free_extent_state(es);
  78 }
  79
  80 static void free_extent_buffer_final(struct extent_buffer *eb);
  81 void extent_io_tree_cleanup(struct extent_io_tree *tree)
  82 {
  83         struct extent_buffer *eb;
  84
  85         while(!list_empty(&tree->lru)) {
  86                 eb = list_entry(tree->lru.next, struct extent_buffer, lru);
  87                 if (eb->refs) {
  88                         fprintf(stderr,
  89                                 "extent buffer leak: start %llu len %u\n",
  90                                 (unsigned long long)eb->start, eb->len);
  91                         free_extent_buffer_nocache(eb);
  92                 } else {
  93                         free_extent_buffer_final(eb);
  94                 }
  95         }
  96
  97         cache_tree_free_extents(&tree->state, free_extent_state_func);
  98 }
  99
 100 static inline void update_extent_state(struct extent_state *state)
 101 {
 102         state->cache_node.start = state->start;
 103         state->cache_node.size = state->end + 1 - state->start;
 104 }
 105
 106 /*
 107  * Utility function to look for merge candidates inside a given range.
 108  * Any extents with matching state are merged together into a single
 109  * extent in the tree. Extents with EXTENT_IO in their state field are
 110  * not merged
 111  */
 112 static int merge_state(struct extent_io_tree *tree,
 113                        struct extent_state *state)
 114 {
 115         struct extent_state *other;
 116         struct cache_extent *other_node;
 117
 118         if (state->state & EXTENT_IOBITS)
 119                 return 0;
 120
 121         other_node = prev_cache_extent(&state->cache_node);
 122         if (other_node) {
 123                 other = container_of(other_node, struct extent_state,
 124                                      cache_node);
 125                 if (other->end == state->start - 1 &&
 126                     other->state == state->state) {
 127                         state->start = other->start;
 128                         update_extent_state(state);
 129                         remove_cache_extent(&tree->state, &other->cache_node);
 130                         btrfs_free_extent_state(other);
 131                 }
 132         }
 133         other_node = next_cache_extent(&state->cache_node);
 134         if (other_node) {
 135                 other = container_of(other_node, struct extent_state,
 136                                      cache_node);
 137                 if (other->start == state->end + 1 &&
 138                     other->state == state->state) {
 139                         other->start = state->start;
 140                         update_extent_state(other);
 141                         remove_cache_extent(&tree->state, &state->cache_node);
 142                         btrfs_free_extent_state(state);
 143                 }
 144         }
 145         return 0;
 146 }
 147
 148 /*
 149  * insert an extent_state struct into the tree.  'bits' are set on the
 150  * struct before it is inserted.
 151  */
 152 static int insert_state(struct extent_io_tree *tree,
 153                         struct extent_state *state, u64 start, u64 end,
 154                         int bits)
 155 {
 156         int ret;
 157
 158         BUG_ON(end < start);
 159         state->state |= bits;
 160         state->start = start;
 161         state->end = end;
 162         update_extent_state(state);
 163         ret = insert_cache_extent(&tree->state, &state->cache_node);
 164         BUG_ON(ret);
 165         merge_state(tree, state);
 166         return 0;
 167 }
 168
 169 /*
 170  * split a given extent state struct in two, inserting the preallocated
 171  * struct 'prealloc' as the newly created second half.  'split' indicates an
 172  * offset inside 'orig' where it should be split.
 173  */
 174 static int split_state(struct extent_io_tree *tree, struct extent_state *orig,
 175                        struct extent_state *prealloc, u64 split)
 176 {
 177         int ret;
 178         prealloc->start = orig->start;
 179         prealloc->end = split - 1;
 180         prealloc->state = orig->state;
 181         update_extent_state(prealloc);
 182         orig->start = split;
 183         update_extent_state(orig);
 184         ret = insert_cache_extent(&tree->state, &prealloc->cache_node);
 185         BUG_ON(ret);
 186         return 0;
 187 }
 188
 189 /*
 190  * clear some bits on a range in the tree.
 191  */
 192 static int clear_state_bit(struct extent_io_tree *tree,
 193                             struct extent_state *state, int bits)
 194 {
 195         int ret = state->state & bits;
 196
 197         state->state &= ~bits;
 198         if (state->state == 0) {
 199                 remove_cache_extent(&tree->state, &state->cache_node);
 200                 btrfs_free_extent_state(state);
 201         } else {
 202                 merge_state(tree, state);
 203         }
 204         return ret;
 205 }
 206
 207 /*
 208  * clear some bits on a range in the tree.
 209  */
 210 int clear_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, int bits)
 211 {
 212         struct extent_state *state;
 213         struct extent_state *prealloc = NULL;
 214         struct cache_extent *node;
 215         u64 last_end;
 216         int err;
 217         int set = 0;
 218
 219 again:
 220         if (!prealloc) {
 221                 prealloc = alloc_extent_state();
 222                 if (!prealloc)
 223                         return -ENOMEM;
 224         }
 225
 226         /*
 227          * this search will find the extents that end after
 228          * our range starts
 229          */
 230         node = search_cache_extent(&tree->state, start);
 231         if (!node)
 232                 goto out;
 233         state = container_of(node, struct extent_state, cache_node);
 234         if (state->start > end)
 235                 goto out;
 236         last_end = state->end;
 237
 238         /*
 239          *     | ---- desired range ---- |
 240          *  | state | or
 241          *  | ------------- state -------------- |
 242          *
 243          * We need to split the extent we found, and may flip
 244          * bits on second half.
 245          *
 246          * If the extent we found extends past our range, we
 247          * just split and search again.  It'll get split again
 248          * the next time though.
 249          *
 250          * If the extent we found is inside our range, we clear
 251          * the desired bit on it.
 252          */
 253         if (state->start < start) {
 254                 err = split_state(tree, state, prealloc, start);
 255                 BUG_ON(err == -EEXIST);
 256                 prealloc = NULL;
 257                 if (err)
 258                         goto out;
 259                 if (state->end <= end) {
 260                         set |= clear_state_bit(tree, state, bits);
 261                         if (last_end == (u64)-1)
 262                                 goto out;
 263                         start = last_end + 1;
 264                 } else {
 265                         start = state->start;
 266                 }
 267                 goto search_again;
 268         }
 269         /*
 270          * | ---- desired range ---- |
 271          *                        | state |
 272          * We need to split the extent, and clear the bit
 273          * on the first half
 274          */
 275         if (state->start <= end && state->end > end) {
 276                 err = split_state(tree, state, prealloc, end + 1);
 277                 BUG_ON(err == -EEXIST);
 278
 279                 set |= clear_state_bit(tree, prealloc, bits);
 280                 prealloc = NULL;
 281                 goto out;
 282         }
 283
 284         start = state->end + 1;
 285         set |= clear_state_bit(tree, state, bits);
 286         if (last_end == (u64)-1)
 287                 goto out;
 288         start = last_end + 1;
 289         goto search_again;
 290 out:
 291         if (prealloc)
 292                 btrfs_free_extent_state(prealloc);
 293         return set;
 294
 295 search_again:
 296         if (start > end)
 297                 goto out;
 298         goto again;
 299 }
 300
 301 /*
 302  * set some bits on a range in the tree.
 303  */
 304 int set_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, int bits)
 305 {
 306         struct extent_state *state;
 307         struct extent_state *prealloc = NULL;
 308         struct cache_extent *node;
 309         int err = 0;
 310         u64 last_start;
 311         u64 last_end;
 312 again:
 313         if (!prealloc) {
 314                 prealloc = alloc_extent_state();
 315                 if (!prealloc)
 316                         return -ENOMEM;
 317         }
 318
 319         /*
 320          * this search will find the extents that end after
 321          * our range starts
 322          */
 323         node = search_cache_extent(&tree->state, start);
 324         if (!node) {
 325                 err = insert_state(tree, prealloc, start, end, bits);
 326                 BUG_ON(err == -EEXIST);
 327                 prealloc = NULL;
 328                 goto out;
 329         }
 330
 331         state = container_of(node, struct extent_state, cache_node);
 332         last_start = state->start;
 333         last_end = state->end;
 334
 335         /*
 336          * | ---- desired range ---- |
 337          * | state |
 338          *
 339          * Just lock what we found and keep going
 340          */
 341         if (state->start == start && state->end <= end) {
 342                 state->state |= bits;
 343                 merge_state(tree, state);
 344                 if (last_end == (u64)-1)
 345                         goto out;
 346                 start = last_end + 1;
 347                 goto search_again;
 348         }
 349         /*
 350          *     | ---- desired range ---- |
 351          * | state |
 352          *   or
 353          * | ------------- state -------------- |
 354          *
 355          * We need to split the extent we found, and may flip bits on
 356          * second half.
 357          *
 358          * If the extent we found extends past our
 359          * range, we just split and search again.  It'll get split
 360          * again the next time though.
 361          *
 362          * If the extent we found is inside our range, we set the
 363          * desired bit on it.
 364          */
 365         if (state->start < start) {
 366                 err = split_state(tree, state, prealloc, start);
 367                 BUG_ON(err == -EEXIST);
 368                 prealloc = NULL;
 369                 if (err)
 370                         goto out;
 371                 if (state->end <= end) {
 372                         state->state |= bits;
 373                         start = state->end + 1;
 374                         merge_state(tree, state);
 375                         if (last_end == (u64)-1)
 376                                 goto out;
 377                         start = last_end + 1;
 378                 } else {
 379                         start = state->start;
 380                 }
 381                 goto search_again;
 382         }
 383         /*
 384          * | ---- desired range ---- |
 385          *     | state | or               | state |
 386          *
 387          * There's a hole, we need to insert something in it and
 388          * ignore the extent we found.
 389          */
 390         if (state->start > start) {
 391                 u64 this_end;
 392                 if (end < last_start)
 393                         this_end = end;
 394                 else
 395                         this_end = last_start -1;
 396                 err = insert_state(tree, prealloc, start, this_end,
 397                                 bits);
 398                 BUG_ON(err == -EEXIST);
 399                 prealloc = NULL;
 400                 if (err)
 401                         goto out;
 402                 start = this_end + 1;
 403                 goto search_again;
 404         }
 405         /*
 406          * | ---- desired range ---- |
 407          * | ---------- state ---------- |
 408          * We need to split the extent, and set the bit
 409          * on the first half
 410          */
 411         err = split_state(tree, state, prealloc, end + 1);
 412         BUG_ON(err == -EEXIST);
 413
 414         state->state |= bits;
 415         merge_state(tree, prealloc);
 416         prealloc = NULL;
 417 out:
 418         if (prealloc)
 419                 btrfs_free_extent_state(prealloc);
 420         return err;
 421 search_again:
 422         if (start > end)
 423                 goto out;
 424         goto again;
 425 }
 426
 427 int set_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end)
 428 {
 429         return set_extent_bits(tree, start, end, EXTENT_DIRTY);
 430 }
 431
 432 int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end)
 433 {
 434         return clear_extent_bits(tree, start, end, EXTENT_DIRTY);
 435 }
 436
 437 int find_first_extent_bit(struct extent_io_tree *tree, u64 start,
 438                           u64 *start_ret, u64 *end_ret, int bits)
 439 {
 440         struct cache_extent *node;
 441         struct extent_state *state;
 442         int ret = 1;
 443
 444         /*
 445          * this search will find all the extents that end after
 446          * our range starts.
 447          */
 448         node = search_cache_extent(&tree->state, start);
 449         if (!node)
 450                 goto out;
 451
 452         while(1) {
 453                 state = container_of(node, struct extent_state, cache_node);
 454                 if (state->end >= start && (state->state & bits)) {
 455                         *start_ret = state->start;
 456                         *end_ret = state->end;
 457                         ret = 0;
 458                         break;
 459                 }
 460                 node = next_cache_extent(node);
 461                 if (!node)
 462                         break;
 463         }
 464 out:
 465         return ret;
 466 }
 467
 468 int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end,
 469                    int bits, int filled)
 470 {
 471         struct extent_state *state = NULL;
 472         struct cache_extent *node;
 473         int bitset = 0;
 474
 475         node = search_cache_extent(&tree->state, start);
 476         while (node && start <= end) {
 477                 state = container_of(node, struct extent_state, cache_node);
 478
 479                 if (filled && state->start > start) {
 480                         bitset = 0;
 481                         break;
 482                 }
 483                 if (state->start > end)
 484                         break;
 485                 if (state->state & bits) {
 486                         bitset = 1;
 487                         if (!filled)
 488                                 break;
 489                 } else if (filled) {
 490                         bitset = 0;
 491                         break;
 492                 }
 493                 start = state->end + 1;
 494                 if (start > end)
 495                         break;
 496                 node = next_cache_extent(node);
 497                 if (!node) {
 498                         if (filled)
 499                                 bitset = 0;
 500                         break;
 501                 }
 502         }
 503         return bitset;
 504 }
 505
 506 int set_state_private(struct extent_io_tree *tree, u64 start, u64 private)
 507 {
 508         struct cache_extent *node;
 509         struct extent_state *state;
 510         int ret = 0;
 511
 512         node = search_cache_extent(&tree->state, start);
 513         if (!node) {
 514                 ret = -ENOENT;
 515                 goto out;
 516         }
 517         state = container_of(node, struct extent_state, cache_node);
 518         if (state->start != start) {
 519                 ret = -ENOENT;
 520                 goto out;
 521         }
 522         state->xprivate = private;
 523 out:
 524         return ret;
 525 }
 526
 527 int get_state_private(struct extent_io_tree *tree, u64 start, u64 *private)
 528 {
 529         struct cache_extent *node;
 530         struct extent_state *state;
 531         int ret = 0;
 532
 533         node = search_cache_extent(&tree->state, start);
 534         if (!node) {
 535                 ret = -ENOENT;
 536                 goto out;
 537         }
 538         state = container_of(node, struct extent_state, cache_node);
 539         if (state->start != start) {
 540                 ret = -ENOENT;
 541                 goto out;
 542         }
 543         *private = state->xprivate;
 544 out:
 545         return ret;
 546 }
 547
 548 static struct extent_buffer *__alloc_extent_buffer(struct btrfs_fs_info *info,
 549                                                    u64 bytenr, u32 blocksize)
 550 {
 551         struct extent_buffer *eb;
 552
 553         eb = calloc(1, sizeof(struct extent_buffer) + blocksize);
 554         if (!eb)
 555                 return NULL;
 556
 557         eb->start = bytenr;
 558         eb->len = blocksize;
 559         eb->refs = 1;
 560         eb->flags = 0;
 561         eb->fd = -1;
 562         eb->dev_bytenr = (u64)-1;
 563         eb->cache_node.start = bytenr;
 564         eb->cache_node.size = blocksize;
 565         eb->fs_info = info;
 566         eb->tree = &info->extent_cache;
 567         INIT_LIST_HEAD(&eb->recow);
 568         INIT_LIST_HEAD(&eb->lru);
 569
 570         return eb;
 571 }
 572
 573 struct extent_buffer *btrfs_clone_extent_buffer(struct extent_buffer *src)
 574 {
 575         struct extent_buffer *new;
 576
 577         new = __alloc_extent_buffer(src->fs_info, src->start, src->len);
 578         if (!new)
 579                 return NULL;
 580         /* cloned eb is not linked into fs_info->extent_cache */
 581         new->tree = NULL;
 582
 583         copy_extent_buffer(new, src, 0, 0, src->len);
 584         new->flags |= EXTENT_BUFFER_DUMMY;
 585
 586         return new;
 587 }
 588
 589 static void free_extent_buffer_final(struct extent_buffer *eb)
 590 {
 591         struct extent_io_tree *tree = eb->tree;
 592
 593         BUG_ON(eb->refs);
 594         BUG_ON(tree && tree->cache_size < eb->len);
 595         list_del_init(&eb->lru);
 596         if (!(eb->flags & EXTENT_BUFFER_DUMMY)) {
 597                 remove_cache_extent(&tree->cache, &eb->cache_node);
 598                 tree->cache_size -= eb->len;
 599         }
 600         free(eb);
 601 }
 602
 603 static void free_extent_buffer_internal(struct extent_buffer *eb, bool free_now)
 604 {
 605         if (!eb || IS_ERR(eb))
 606                 return;
 607
 608         eb->refs--;
 609         BUG_ON(eb->refs < 0);
 610         if (eb->refs == 0) {
 611                 BUG_ON(eb->flags & EXTENT_DIRTY);
 612                 list_del_init(&eb->recow);
 613                 if (eb->flags & EXTENT_BUFFER_DUMMY || free_now)
 614                         free_extent_buffer_final(eb);
 615         }
 616 }
 617
 618 void free_extent_buffer(struct extent_buffer *eb)
 619 {
 620         free_extent_buffer_internal(eb, 0);
 621 }
 622
 623 void free_extent_buffer_nocache(struct extent_buffer *eb)
 624 {
 625         free_extent_buffer_internal(eb, 1);
 626 }
 627
 628 struct extent_buffer *find_extent_buffer(struct extent_io_tree *tree,
 629                                          u64 bytenr, u32 blocksize)
 630 {
 631         struct extent_buffer *eb = NULL;
 632         struct cache_extent *cache;
 633
 634         cache = lookup_cache_extent(&tree->cache, bytenr, blocksize);
 635         if (cache && cache->start == bytenr &&
 636             cache->size == blocksize) {
 637                 eb = container_of(cache, struct extent_buffer, cache_node);
 638                 list_move_tail(&eb->lru, &tree->lru);
 639                 eb->refs++;
 640         }
 641         return eb;
 642 }
 643
 644 struct extent_buffer *find_first_extent_buffer(struct extent_io_tree *tree,
 645                                                u64 start)
 646 {
 647         struct extent_buffer *eb = NULL;
 648         struct cache_extent *cache;
 649
 650         cache = search_cache_extent(&tree->cache, start);
 651         if (cache) {
 652                 eb = container_of(cache, struct extent_buffer, cache_node);
 653                 list_move_tail(&eb->lru, &tree->lru);
 654                 eb->refs++;
 655         }
 656         return eb;
 657 }
 658
 659 static void trim_extent_buffer_cache(struct extent_io_tree *tree)
 660 {
 661         struct extent_buffer *eb, *tmp;
 662
 663         list_for_each_entry_safe(eb, tmp, &tree->lru, lru) {
 664                 if (eb->refs == 0)
 665                         free_extent_buffer_final(eb);
 666                 if (tree->cache_size <= ((tree->max_cache_size * 9) / 10))
 667                         break;
 668         }
 669 }
 670
 671 struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
 672                                           u64 bytenr, u32 blocksize)
 673 {
 674         struct extent_buffer *eb;
 675         struct extent_io_tree *tree = &fs_info->extent_cache;
 676         struct cache_extent *cache;
 677
 678         cache = lookup_cache_extent(&tree->cache, bytenr, blocksize);
 679         if (cache && cache->start == bytenr &&
 680             cache->size == blocksize) {
 681                 eb = container_of(cache, struct extent_buffer, cache_node);
 682                 list_move_tail(&eb->lru, &tree->lru);
 683                 eb->refs++;
 684         } else {
 685                 int ret;
 686
 687                 if (cache) {
 688                         eb = container_of(cache, struct extent_buffer,
 689                                           cache_node);
 690                         free_extent_buffer(eb);
 691                 }
 692                 eb = __alloc_extent_buffer(fs_info, bytenr, blocksize);
 693                 if (!eb)
 694                         return NULL;
 695                 ret = insert_cache_extent(&tree->cache, &eb->cache_node);
 696                 if (ret) {
 697                         free(eb);
 698                         return NULL;
 699                 }
 700                 list_add_tail(&eb->lru, &tree->lru);
 701                 tree->cache_size += blocksize;
 702                 if (tree->cache_size >= tree->max_cache_size)
 703                         trim_extent_buffer_cache(tree);
 704         }
 705         return eb;
 706 }
 707
 708 int read_extent_from_disk(struct extent_buffer *eb,
 709                           unsigned long offset, unsigned long len)
 710 {
 711         int ret;
 712         ret = pread(eb->fd, eb->data + offset, len, eb->dev_bytenr);
 713         if (ret < 0) {
 714                 ret = -errno;
 715                 goto out;
 716         }
 717         if (ret != len) {
 718                 ret = -EIO;
 719                 goto out;
 720         }
 721         ret = 0;
 722 out:
 723         return ret;
 724 }
 725
 726 int write_extent_to_disk(struct extent_buffer *eb)
 727 {
 728         int ret;
 729         ret = pwrite(eb->fd, eb->data, eb->len, eb->dev_bytenr);
 730         if (ret < 0)
 731                 goto out;
 732         if (ret != eb->len) {
 733                 ret = -EIO;
 734                 goto out;
 735         }
 736         ret = 0;
 737 out:
 738         return ret;
 739 }
 740
 741 int read_data_from_disk(struct btrfs_fs_info *info, void *buf, u64 offset,
 742                         u64 bytes, int mirror)
 743 {
 744         struct btrfs_multi_bio *multi = NULL;
 745         struct btrfs_device *device;
 746         u64 bytes_left = bytes;
 747         u64 read_len;
 748         u64 total_read = 0;
 749         int ret;
 750
 751         while (bytes_left) {
 752                 read_len = bytes_left;
 753                 ret = btrfs_map_block(info, READ, offset, &read_len, &multi,
 754                                       mirror, NULL);
 755                 if (ret) {
 756                         fprintf(stderr, "Couldn't map the block %Lu\n",
 757                                 offset);
 758                         return -EIO;
 759                 }
 760                 device = multi->stripes[0].dev;
 761
 762                 read_len = min(bytes_left, read_len);
 763                 if (device->fd <= 0) {
 764                         kfree(multi);
 765                         return -EIO;
 766                 }
 767
 768                 ret = pread(device->fd, buf + total_read, read_len,
 769                             multi->stripes[0].physical);
 770                 kfree(multi);
 771                 if (ret < 0) {
 772                         fprintf(stderr, "Error reading %Lu, %d\n", offset,
 773                                 ret);
 774                         return ret;
 775                 }
 776                 if (ret != read_len) {
 777                         fprintf(stderr, "Short read for %Lu, read %d, "
 778                                 "read_len %Lu\n", offset, ret, read_len);
 779                         return -EIO;
 780                 }
 781
 782                 bytes_left -= read_len;
 783                 offset += read_len;
 784                 total_read += read_len;
 785         }
 786
 787         return 0;
 788 }
 789
 790 int write_data_to_disk(struct btrfs_fs_info *info, void *buf, u64 offset,
 791                       u64 bytes, int mirror)
 792 {
 793         struct btrfs_multi_bio *multi = NULL;
 794         struct btrfs_device *device;
 795         u64 bytes_left = bytes;
 796         u64 this_len;
 797         u64 total_write = 0;
 798         u64 *raid_map = NULL;
 799         u64 dev_bytenr;
 800         int dev_nr;
 801         int ret = 0;
 802
 803         while (bytes_left > 0) {
 804                 this_len = bytes_left;
 805                 dev_nr = 0;
 806
 807                 ret = btrfs_map_block(info, WRITE, offset, &this_len, &multi,
 808                                       mirror, &raid_map);
 809                 if (ret) {
 810                         fprintf(stderr, "Couldn't map the block %Lu\n",
 811                                 offset);
 812                         return -EIO;
 813                 }
 814
 815                 if (raid_map) {
 816                         struct extent_buffer *eb;
 817                         u64 stripe_len = this_len;
 818
 819                         this_len = min(this_len, bytes_left);
 820                         this_len = min(this_len, (u64)info->nodesize);
 821
 822                         eb = malloc(sizeof(struct extent_buffer) + this_len);
 823                         if (!eb) {
 824                                 fprintf(stderr, "cannot allocate memory for eb\n");
 825                                 ret = -ENOMEM;
 826                                 goto out;
 827                         }
 828
 829                         memset(eb, 0, sizeof(struct extent_buffer) + this_len);
 830                         eb->start = offset;
 831                         eb->len = this_len;
 832
 833                         memcpy(eb->data, buf + total_write, this_len);
 834                         ret = write_raid56_with_parity(info, eb, multi,
 835                                                        stripe_len, raid_map);
 836                         BUG_ON(ret);
 837
 838                         free(eb);
 839                         kfree(raid_map);
 840                         raid_map = NULL;
 841                 } else while (dev_nr < multi->num_stripes) {
 842                         device = multi->stripes[dev_nr].dev;
 843                         if (device->fd <= 0) {
 844                                 kfree(multi);
 845                                 return -EIO;
 846                         }
 847
 848                         dev_bytenr = multi->stripes[dev_nr].physical;
 849                         this_len = min(this_len, bytes_left);
 850                         dev_nr++;
 851
 852                         ret = pwrite(device->fd, buf + total_write, this_len, dev_bytenr);
 853                         if (ret != this_len) {
 854                                 if (ret < 0) {
 855                                         fprintf(stderr, "Error writing to "
 856                                                 "device %d\n", errno);
 857                                         ret = errno;
 858                                         kfree(multi);
 859                                         return ret;
 860                                 } else {
 861                                         fprintf(stderr, "Short write\n");
 862                                         kfree(multi);
 863                                         return -EIO;
 864                                 }
 865                         }
 866                 }
 867
 868                 BUG_ON(bytes_left < this_len);
 869
 870                 bytes_left -= this_len;
 871                 offset += this_len;
 872                 total_write += this_len;
 873
 874                 kfree(multi);
 875                 multi = NULL;
 876         }
 877         return 0;
 878
 879 out:
 880         kfree(raid_map);
 881         return ret;
 882 }
 883
 884 int set_extent_buffer_dirty(struct extent_buffer *eb)
 885 {
 886         struct extent_io_tree *tree = eb->tree;
 887         if (!(eb->flags & EXTENT_DIRTY)) {
 888                 eb->flags |= EXTENT_DIRTY;
 889                 set_extent_dirty(tree, eb->start, eb->start + eb->len - 1);
 890                 extent_buffer_get(eb);
 891         }
 892         return 0;
 893 }
 894
 895 int clear_extent_buffer_dirty(struct extent_buffer *eb)
 896 {
 897         struct extent_io_tree *tree = eb->tree;
 898         if (eb->flags & EXTENT_DIRTY) {
 899                 eb->flags &= ~EXTENT_DIRTY;
 900                 clear_extent_dirty(tree, eb->start, eb->start + eb->len - 1);
 901                 free_extent_buffer(eb);
 902         }
 903         return 0;
 904 }
 905
 906 int memcmp_extent_buffer(struct extent_buffer *eb, const void *ptrv,
 907                          unsigned long start, unsigned long len)
 908 {
 909         return memcmp(eb->data + start, ptrv, len);
 910 }
 911
 912 void read_extent_buffer(struct extent_buffer *eb, void *dst,
 913                         unsigned long start, unsigned long len)
 914 {
 915         memcpy(dst, eb->data + start, len);
 916 }
 917
 918 void write_extent_buffer(struct extent_buffer *eb, const void *src,
 919                          unsigned long start, unsigned long len)
 920 {
 921         memcpy(eb->data + start, src, len);
 922 }
 923
 924 void copy_extent_buffer(struct extent_buffer *dst, struct extent_buffer *src,
 925                         unsigned long dst_offset, unsigned long src_offset,
 926                         unsigned long len)
 927 {
 928         memcpy(dst->data + dst_offset, src->data + src_offset, len);
 929 }
 930
 931 void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
 932                            unsigned long src_offset, unsigned long len)
 933 {
 934         memmove(dst->data + dst_offset, dst->data + src_offset, len);
 935 }
 936
 937 void memset_extent_buffer(struct extent_buffer *eb, char c,
 938                           unsigned long start, unsigned long len)
 939 {
 940         memset(eb->data + start, c, len);
 941 }
 942
 943 int extent_buffer_test_bit(struct extent_buffer *eb, unsigned long start,
 944                            unsigned long nr)
 945 {
 946         return le_test_bit(nr, (u8 *)eb->data + start);
 947 }