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