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