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