Btrfs-progs: enhance btrfs-image to restore image onto multiple disks
[platform/upstream/btrfs-progs.git] / 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 }