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 extent_io_tree *tree,
 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->tree = tree;
 562         eb->fd = -1;
 563         eb->dev_bytenr = (u64)-1;
 564         eb->cache_node.start = bytenr;
 565         eb->cache_node.size = blocksize;
 566         INIT_LIST_HEAD(&eb->recow);
 567
 568         return eb;
 569 }
 570
 571 struct extent_buffer *btrfs_clone_extent_buffer(struct extent_buffer *src)
 572 {
 573         struct extent_buffer *new;
 574
 575         new = __alloc_extent_buffer(NULL, src->start, src->len);
 576         if (!new)
 577                 return NULL;
 578
 579         copy_extent_buffer(new, src, 0, 0, src->len);
 580         new->flags |= EXTENT_BUFFER_DUMMY;
 581
 582         return new;
 583 }
 584
 585 static void free_extent_buffer_final(struct extent_buffer *eb)
 586 {
 587         struct extent_io_tree *tree = eb->tree;
 588
 589         BUG_ON(eb->refs);
 590         BUG_ON(tree->cache_size < eb->len);
 591         list_del_init(&eb->lru);
 592         if (!(eb->flags & EXTENT_BUFFER_DUMMY)) {
 593                 remove_cache_extent(&tree->cache, &eb->cache_node);
 594                 tree->cache_size -= eb->len;
 595         }
 596         free(eb);
 597 }
 598
 599 static void free_extent_buffer_internal(struct extent_buffer *eb, bool free_now)
 600 {
 601         if (!eb || IS_ERR(eb))
 602                 return;
 603
 604         eb->refs--;
 605         BUG_ON(eb->refs < 0);
 606         if (eb->refs == 0) {
 607                 BUG_ON(eb->flags & EXTENT_DIRTY);
 608                 list_del_init(&eb->recow);
 609                 if (eb->flags & EXTENT_BUFFER_DUMMY || free_now)
 610                         free_extent_buffer_final(eb);
 611         }
 612 }
 613
 614 void free_extent_buffer(struct extent_buffer *eb)
 615 {
 616         free_extent_buffer_internal(eb, 0);
 617 }
 618
 619 void free_extent_buffer_nocache(struct extent_buffer *eb)
 620 {
 621         free_extent_buffer_internal(eb, 1);
 622 }
 623
 624 struct extent_buffer *find_extent_buffer(struct extent_io_tree *tree,
 625                                          u64 bytenr, u32 blocksize)
 626 {
 627         struct extent_buffer *eb = NULL;
 628         struct cache_extent *cache;
 629
 630         cache = lookup_cache_extent(&tree->cache, bytenr, blocksize);
 631         if (cache && cache->start == bytenr &&
 632             cache->size == blocksize) {
 633                 eb = container_of(cache, struct extent_buffer, cache_node);
 634                 list_move_tail(&eb->lru, &tree->lru);
 635                 eb->refs++;
 636         }
 637         return eb;
 638 }
 639
 640 struct extent_buffer *find_first_extent_buffer(struct extent_io_tree *tree,
 641                                                u64 start)
 642 {
 643         struct extent_buffer *eb = NULL;
 644         struct cache_extent *cache;
 645
 646         cache = search_cache_extent(&tree->cache, start);
 647         if (cache) {
 648                 eb = container_of(cache, struct extent_buffer, cache_node);
 649                 list_move_tail(&eb->lru, &tree->lru);
 650                 eb->refs++;
 651         }
 652         return eb;
 653 }
 654
 655 static void trim_extent_buffer_cache(struct extent_io_tree *tree)
 656 {
 657         struct extent_buffer *eb, *tmp;
 658
 659         list_for_each_entry_safe(eb, tmp, &tree->lru, lru) {
 660                 if (eb->refs == 0)
 661                         free_extent_buffer_final(eb);
 662                 if (tree->cache_size <= ((tree->max_cache_size * 9) / 10))
 663                         break;
 664         }
 665 }
 666
 667 struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree,
 668                                           u64 bytenr, u32 blocksize)
 669 {
 670         struct extent_buffer *eb;
 671         struct cache_extent *cache;
 672
 673         cache = lookup_cache_extent(&tree->cache, bytenr, blocksize);
 674         if (cache && cache->start == bytenr &&
 675             cache->size == blocksize) {
 676                 eb = container_of(cache, struct extent_buffer, cache_node);
 677                 list_move_tail(&eb->lru, &tree->lru);
 678                 eb->refs++;
 679         } else {
 680                 int ret;
 681
 682                 if (cache) {
 683                         eb = container_of(cache, struct extent_buffer,
 684                                           cache_node);
 685                         free_extent_buffer(eb);
 686                 }
 687                 eb = __alloc_extent_buffer(tree, bytenr, blocksize);
 688                 if (!eb)
 689                         return NULL;
 690                 ret = insert_cache_extent(&tree->cache, &eb->cache_node);
 691                 if (ret) {
 692                         free(eb);
 693                         return NULL;
 694                 }
 695                 list_add_tail(&eb->lru, &tree->lru);
 696                 tree->cache_size += blocksize;
 697                 if (tree->cache_size >= tree->max_cache_size)
 698                         trim_extent_buffer_cache(tree);
 699         }
 700         return eb;
 701 }
 702
 703 int read_extent_from_disk(struct extent_buffer *eb,
 704                           unsigned long offset, unsigned long len)
 705 {
 706         int ret;
 707         ret = pread(eb->fd, eb->data + offset, len, eb->dev_bytenr);
 708         if (ret < 0) {
 709                 ret = -errno;
 710                 goto out;
 711         }
 712         if (ret != len) {
 713                 ret = -EIO;
 714                 goto out;
 715         }
 716         ret = 0;
 717 out:
 718         return ret;
 719 }
 720
 721 int write_extent_to_disk(struct extent_buffer *eb)
 722 {
 723         int ret;
 724         ret = pwrite(eb->fd, eb->data, eb->len, eb->dev_bytenr);
 725         if (ret < 0)
 726                 goto out;
 727         if (ret != eb->len) {
 728                 ret = -EIO;
 729                 goto out;
 730         }
 731         ret = 0;
 732 out:
 733         return ret;
 734 }
 735
 736 int read_data_from_disk(struct btrfs_fs_info *info, void *buf, u64 offset,
 737                         u64 bytes, int mirror)
 738 {
 739         struct btrfs_multi_bio *multi = NULL;
 740         struct btrfs_device *device;
 741         u64 bytes_left = bytes;
 742         u64 read_len;
 743         u64 total_read = 0;
 744         int ret;
 745
 746         while (bytes_left) {
 747                 read_len = bytes_left;
 748                 ret = btrfs_map_block(info, READ, offset, &read_len, &multi,
 749                                       mirror, NULL);
 750                 if (ret) {
 751                         fprintf(stderr, "Couldn't map the block %Lu\n",
 752                                 offset);
 753                         return -EIO;
 754                 }
 755                 device = multi->stripes[0].dev;
 756
 757                 read_len = min(bytes_left, read_len);
 758                 if (device->fd <= 0) {
 759                         kfree(multi);
 760                         return -EIO;
 761                 }
 762
 763                 ret = pread(device->fd, buf + total_read, read_len,
 764                             multi->stripes[0].physical);
 765                 kfree(multi);
 766                 if (ret < 0) {
 767                         fprintf(stderr, "Error reading %Lu, %d\n", offset,
 768                                 ret);
 769                         return ret;
 770                 }
 771                 if (ret != read_len) {
 772                         fprintf(stderr, "Short read for %Lu, read %d, "
 773                                 "read_len %Lu\n", offset, ret, read_len);
 774                         return -EIO;
 775                 }
 776
 777                 bytes_left -= read_len;
 778                 offset += read_len;
 779                 total_read += read_len;
 780         }
 781
 782         return 0;
 783 }
 784
 785 int write_data_to_disk(struct btrfs_fs_info *info, void *buf, u64 offset,
 786                       u64 bytes, int mirror)
 787 {
 788         struct btrfs_multi_bio *multi = NULL;
 789         struct btrfs_device *device;
 790         u64 bytes_left = bytes;
 791         u64 this_len;
 792         u64 total_write = 0;
 793         u64 *raid_map = NULL;
 794         u64 dev_bytenr;
 795         int dev_nr;
 796         int ret = 0;
 797
 798         while (bytes_left > 0) {
 799                 this_len = bytes_left;
 800                 dev_nr = 0;
 801
 802                 ret = btrfs_map_block(info, WRITE, offset, &this_len, &multi,
 803                                       mirror, &raid_map);
 804                 if (ret) {
 805                         fprintf(stderr, "Couldn't map the block %Lu\n",
 806                                 offset);
 807                         return -EIO;
 808                 }
 809
 810                 if (raid_map) {
 811                         struct extent_buffer *eb;
 812                         u64 stripe_len = this_len;
 813
 814                         this_len = min(this_len, bytes_left);
 815                         this_len = min(this_len, (u64)info->nodesize);
 816
 817                         eb = malloc(sizeof(struct extent_buffer) + this_len);
 818                         if (!eb) {
 819                                 fprintf(stderr, "cannot allocate memory for eb\n");
 820                                 ret = -ENOMEM;
 821                                 goto out;
 822                         }
 823
 824                         memset(eb, 0, sizeof(struct extent_buffer) + this_len);
 825                         eb->start = offset;
 826                         eb->len = this_len;
 827
 828                         memcpy(eb->data, buf + total_write, this_len);
 829                         ret = write_raid56_with_parity(info, eb, multi,
 830                                                        stripe_len, raid_map);
 831                         BUG_ON(ret);
 832
 833                         free(eb);
 834                         kfree(raid_map);
 835                         raid_map = NULL;
 836                 } else while (dev_nr < multi->num_stripes) {
 837                         device = multi->stripes[dev_nr].dev;
 838                         if (device->fd <= 0) {
 839                                 kfree(multi);
 840                                 return -EIO;
 841                         }
 842
 843                         dev_bytenr = multi->stripes[dev_nr].physical;
 844                         this_len = min(this_len, bytes_left);
 845                         dev_nr++;
 846
 847                         ret = pwrite(device->fd, buf + total_write, this_len, dev_bytenr);
 848                         if (ret != this_len) {
 849                                 if (ret < 0) {
 850                                         fprintf(stderr, "Error writing to "
 851                                                 "device %d\n", errno);
 852                                         ret = errno;
 853                                         kfree(multi);
 854                                         return ret;
 855                                 } else {
 856                                         fprintf(stderr, "Short write\n");
 857                                         kfree(multi);
 858                                         return -EIO;
 859                                 }
 860                         }
 861                 }
 862
 863                 BUG_ON(bytes_left < this_len);
 864
 865                 bytes_left -= this_len;
 866                 offset += this_len;
 867                 total_write += this_len;
 868
 869                 kfree(multi);
 870                 multi = NULL;
 871         }
 872         return 0;
 873
 874 out:
 875         kfree(raid_map);
 876         return ret;
 877 }
 878
 879 int set_extent_buffer_dirty(struct extent_buffer *eb)
 880 {
 881         struct extent_io_tree *tree = eb->tree;
 882         if (!(eb->flags & EXTENT_DIRTY)) {
 883                 eb->flags |= EXTENT_DIRTY;
 884                 set_extent_dirty(tree, eb->start, eb->start + eb->len - 1);
 885                 extent_buffer_get(eb);
 886         }
 887         return 0;
 888 }
 889
 890 int clear_extent_buffer_dirty(struct extent_buffer *eb)
 891 {
 892         struct extent_io_tree *tree = eb->tree;
 893         if (eb->flags & EXTENT_DIRTY) {
 894                 eb->flags &= ~EXTENT_DIRTY;
 895                 clear_extent_dirty(tree, eb->start, eb->start + eb->len - 1);
 896                 free_extent_buffer(eb);
 897         }
 898         return 0;
 899 }
 900
 901 int memcmp_extent_buffer(struct extent_buffer *eb, const void *ptrv,
 902                          unsigned long start, unsigned long len)
 903 {
 904         return memcmp(eb->data + start, ptrv, len);
 905 }
 906
 907 void read_extent_buffer(struct extent_buffer *eb, void *dst,
 908                         unsigned long start, unsigned long len)
 909 {
 910         memcpy(dst, eb->data + start, len);
 911 }
 912
 913 void write_extent_buffer(struct extent_buffer *eb, const void *src,
 914                          unsigned long start, unsigned long len)
 915 {
 916         memcpy(eb->data + start, src, len);
 917 }
 918
 919 void copy_extent_buffer(struct extent_buffer *dst, struct extent_buffer *src,
 920                         unsigned long dst_offset, unsigned long src_offset,
 921                         unsigned long len)
 922 {
 923         memcpy(dst->data + dst_offset, src->data + src_offset, len);
 924 }
 925
 926 void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
 927                            unsigned long src_offset, unsigned long len)
 928 {
 929         memmove(dst->data + dst_offset, dst->data + src_offset, len);
 930 }
 931
 932 void memset_extent_buffer(struct extent_buffer *eb, char c,
 933                           unsigned long start, unsigned long len)
 934 {
 935         memset(eb->data + start, c, len);
 936 }
 937
 938 int extent_buffer_test_bit(struct extent_buffer *eb, unsigned long start,
 939                            unsigned long nr)
 940 {
 941         return le_test_bit(nr, (u8 *)eb->data + start);
 942 }