Btrfs-progs: make restore deal with really broken file systems
[platform/upstream/btrfs-progs.git] / disk-io.c
1 /*
2  * Copyright (C) 2007 Oracle.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public
6  * License v2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public
14  * License along with this program; if not, write to the
15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16  * Boston, MA 021110-1307, USA.
17  */
18
19 #define _XOPEN_SOURCE 600
20 #define __USE_XOPEN2K
21 #define _GNU_SOURCE 1
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #include <fcntl.h>
27 #include <unistd.h>
28 #include "kerncompat.h"
29 #include "radix-tree.h"
30 #include "ctree.h"
31 #include "disk-io.h"
32 #include "volumes.h"
33 #include "transaction.h"
34 #include "crc32c.h"
35 #include "utils.h"
36 #include "print-tree.h"
37
38 static int close_all_devices(struct btrfs_fs_info *fs_info);
39
40 static int check_tree_block(struct btrfs_root *root, struct extent_buffer *buf)
41 {
42
43         struct btrfs_fs_devices *fs_devices;
44         int ret = 1;
45
46         if (buf->start != btrfs_header_bytenr(buf)) {
47                 printk("Check tree block failed, want=%Lu, have=%Lu\n",
48                        buf->start, btrfs_header_bytenr(buf));
49                 return ret;
50         }
51
52         fs_devices = root->fs_info->fs_devices;
53         while (fs_devices) {
54                 if (!memcmp_extent_buffer(buf, fs_devices->fsid,
55                                           (unsigned long)btrfs_header_fsid(buf),
56                                           BTRFS_FSID_SIZE)) {
57                         ret = 0;
58                         break;
59                 }
60                 fs_devices = fs_devices->seed;
61         }
62         return ret;
63 }
64
65 u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
66 {
67         return crc32c(seed, data, len);
68 }
69
70 void btrfs_csum_final(u32 crc, char *result)
71 {
72         *(__le32 *)result = ~cpu_to_le32(crc);
73 }
74
75 int csum_tree_block_size(struct extent_buffer *buf, u16 csum_size,
76                          int verify)
77 {
78         char *result;
79         u32 len;
80         u32 crc = ~(u32)0;
81
82         result = malloc(csum_size * sizeof(char));
83         if (!result)
84                 return 1;
85
86         len = buf->len - BTRFS_CSUM_SIZE;
87         crc = crc32c(crc, buf->data + BTRFS_CSUM_SIZE, len);
88         btrfs_csum_final(crc, result);
89
90         if (verify) {
91                 if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
92                         printk("checksum verify failed on %llu found %X "
93                                "wanted %X\n", (unsigned long long)buf->start,
94                                *((int *)result), *((char *)buf->data));
95                         free(result);
96                         return 1;
97                 }
98         } else {
99                 write_extent_buffer(buf, result, 0, csum_size);
100         }
101         free(result);
102         return 0;
103 }
104
105 int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
106                     int verify)
107 {
108         u16 csum_size =
109                 btrfs_super_csum_size(root->fs_info->super_copy);
110         return csum_tree_block_size(buf, csum_size, verify);
111 }
112
113 struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
114                                             u64 bytenr, u32 blocksize)
115 {
116         return find_extent_buffer(&root->fs_info->extent_cache,
117                                   bytenr, blocksize);
118 }
119
120 struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
121                                                  u64 bytenr, u32 blocksize)
122 {
123         return alloc_extent_buffer(&root->fs_info->extent_cache, bytenr,
124                                    blocksize);
125 }
126
127 int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
128                          u64 parent_transid)
129 {
130         int ret;
131         struct extent_buffer *eb;
132         u64 length;
133         struct btrfs_multi_bio *multi = NULL;
134         struct btrfs_device *device;
135
136         eb = btrfs_find_tree_block(root, bytenr, blocksize);
137         if (eb && btrfs_buffer_uptodate(eb, parent_transid)) {
138                 free_extent_buffer(eb);
139                 return 0;
140         }
141
142         length = blocksize;
143         ret = btrfs_map_block(&root->fs_info->mapping_tree, READ,
144                               bytenr, &length, &multi, 0, NULL);
145         BUG_ON(ret);
146         device = multi->stripes[0].dev;
147         device->total_ios++;
148         blocksize = min(blocksize, (u32)(64 * 1024));
149         readahead(device->fd, multi->stripes[0].physical, blocksize);
150         kfree(multi);
151         return 0;
152 }
153
154 static int verify_parent_transid(struct extent_io_tree *io_tree,
155                                  struct extent_buffer *eb, u64 parent_transid,
156                                  int ignore)
157 {
158         int ret;
159
160         if (!parent_transid || btrfs_header_generation(eb) == parent_transid)
161                 return 0;
162
163         if (extent_buffer_uptodate(eb) &&
164             btrfs_header_generation(eb) == parent_transid) {
165                 ret = 0;
166                 goto out;
167         }
168         printk("parent transid verify failed on %llu wanted %llu found %llu\n",
169                (unsigned long long)eb->start,
170                (unsigned long long)parent_transid,
171                (unsigned long long)btrfs_header_generation(eb));
172         if (ignore) {
173                 printk("Ignoring transid failure\n");
174                 return 0;
175         }
176
177         ret = 1;
178 out:
179         clear_extent_buffer_uptodate(io_tree, eb);
180         return ret;
181
182 }
183
184
185 static int read_whole_eb(struct btrfs_fs_info *info, struct extent_buffer *eb, int mirror)
186 {
187         unsigned long offset = 0;
188         struct btrfs_multi_bio *multi = NULL;
189         struct btrfs_device *device;
190         int ret = 0;
191         u64 read_len;
192         unsigned long bytes_left = eb->len;
193
194         while (bytes_left) {
195                 read_len = bytes_left;
196                 ret = btrfs_map_block(&info->mapping_tree, READ,
197                                       eb->start + offset, &read_len, &multi,
198                                       mirror, NULL);
199                 if (ret) {
200                         printk("Couldn't map the block %Lu\n", eb->start + offset);
201                         kfree(multi);
202                         return -EIO;
203                 }
204                 device = multi->stripes[0].dev;
205
206                 if (device->fd == 0) {
207                         kfree(multi);
208                         return -EIO;
209                 }
210
211                 eb->fd = device->fd;
212                 device->total_ios++;
213                 eb->dev_bytenr = multi->stripes[0].physical;
214                 kfree(multi);
215                 multi = NULL;
216
217                 if (read_len > bytes_left)
218                         read_len = bytes_left;
219
220                 ret = read_extent_from_disk(eb, offset, read_len);
221                 if (ret)
222                         return -EIO;
223                 offset += read_len;
224                 bytes_left -= read_len;
225         }
226         return 0;
227 }
228
229 struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
230                                      u32 blocksize, u64 parent_transid)
231 {
232         int ret;
233         struct extent_buffer *eb;
234         u64 best_transid = 0;
235         int mirror_num = 0;
236         int good_mirror = 0;
237         int num_copies;
238         int ignore = 0;
239
240         eb = btrfs_find_create_tree_block(root, bytenr, blocksize);
241         if (!eb)
242                 return NULL;
243
244         if (btrfs_buffer_uptodate(eb, parent_transid))
245                 return eb;
246
247         while (1) {
248                 ret = read_whole_eb(root->fs_info, eb, mirror_num);
249                 if (ret == 0 && check_tree_block(root, eb) == 0 &&
250                     csum_tree_block(root, eb, 1) == 0 &&
251                     verify_parent_transid(eb->tree, eb, parent_transid, ignore)
252                     == 0) {
253                         btrfs_set_buffer_uptodate(eb);
254                         return eb;
255                 }
256                 if (ignore) {
257                         if (check_tree_block(root, eb))
258                                 printk("read block failed check_tree_block\n");
259                         else
260                                 printk("Csum didn't match\n");
261                         break;
262                 }
263                 num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
264                                               eb->start, eb->len);
265                 if (num_copies == 1) {
266                         ignore = 1;
267                         continue;
268                 }
269                 if (btrfs_header_generation(eb) > best_transid) {
270                         best_transid = btrfs_header_generation(eb);
271                         good_mirror = mirror_num;
272                 }
273                 mirror_num++;
274                 if (mirror_num > num_copies) {
275                         mirror_num = good_mirror;
276                         ignore = 1;
277                         continue;
278                 }
279         }
280         free_extent_buffer(eb);
281         return NULL;
282 }
283
284 static int rmw_eb(struct btrfs_fs_info *info,
285                   struct extent_buffer *eb, struct extent_buffer *orig_eb)
286 {
287         int ret;
288         unsigned long orig_off = 0;
289         unsigned long dest_off = 0;
290         unsigned long copy_len = eb->len;
291
292         ret = read_whole_eb(info, eb, 0);
293         if (ret)
294                 return ret;
295
296         if (eb->start + eb->len <= orig_eb->start ||
297             eb->start >= orig_eb->start + orig_eb->len)
298                 return 0;
299         /*
300          * | ----- orig_eb ------- |
301          *         | ----- stripe -------  |
302          *         | ----- orig_eb ------- |
303          *              | ----- orig_eb ------- |
304          */
305         if (eb->start > orig_eb->start)
306                 orig_off = eb->start - orig_eb->start;
307         if (orig_eb->start > eb->start)
308                 dest_off = orig_eb->start - eb->start;
309
310         if (copy_len > orig_eb->len - orig_off)
311                 copy_len = orig_eb->len - orig_off;
312         if (copy_len > eb->len - dest_off)
313                 copy_len = eb->len - dest_off;
314
315         memcpy(eb->data + dest_off, orig_eb->data + orig_off, copy_len);
316         return 0;
317 }
318
319 static void split_eb_for_raid56(struct btrfs_fs_info *info,
320                                 struct extent_buffer *orig_eb,
321                                struct extent_buffer **ebs,
322                                u64 stripe_len, u64 *raid_map,
323                                int num_stripes)
324 {
325         struct extent_buffer *eb;
326         u64 start = orig_eb->start;
327         u64 this_eb_start;
328         int i;
329         int ret;
330
331         for (i = 0; i < num_stripes; i++) {
332                 if (raid_map[i] >= BTRFS_RAID5_P_STRIPE)
333                         break;
334
335                 eb = malloc(sizeof(struct extent_buffer) + stripe_len);
336                 if (!eb)
337                         BUG();
338                 memset(eb, 0, sizeof(struct extent_buffer) + stripe_len);
339
340                 eb->start = raid_map[i];
341                 eb->len = stripe_len;
342                 eb->refs = 1;
343                 eb->flags = 0;
344                 eb->fd = -1;
345                 eb->dev_bytenr = (u64)-1;
346
347                 this_eb_start = raid_map[i];
348
349                 if (start > this_eb_start ||
350                     start + orig_eb->len < this_eb_start + stripe_len) {
351                         ret = rmw_eb(info, eb, orig_eb);
352                         BUG_ON(ret);
353                 } else {
354                         memcpy(eb->data, orig_eb->data + eb->start - start, stripe_len);
355                 }
356                 ebs[i] = eb;
357         }
358 }
359
360 static int write_raid56_with_parity(struct btrfs_fs_info *info,
361                                     struct extent_buffer *eb,
362                                     struct btrfs_multi_bio *multi,
363                                     u64 stripe_len, u64 *raid_map)
364 {
365         struct extent_buffer *ebs[multi->num_stripes], *p_eb = NULL, *q_eb = NULL;
366         int i;
367         int j;
368         int ret;
369         int alloc_size = eb->len;
370
371         if (stripe_len > alloc_size)
372                 alloc_size = stripe_len;
373
374         split_eb_for_raid56(info, eb, ebs, stripe_len, raid_map,
375                             multi->num_stripes);
376
377         for (i = 0; i < multi->num_stripes; i++) {
378                 struct extent_buffer *new_eb;
379                 if (raid_map[i] < BTRFS_RAID5_P_STRIPE) {
380                         ebs[i]->dev_bytenr = multi->stripes[i].physical;
381                         ebs[i]->fd = multi->stripes[i].dev->fd;
382                         multi->stripes[i].dev->total_ios++;
383                         BUG_ON(ebs[i]->start != raid_map[i]);
384                         continue;
385                 }
386                 new_eb = kmalloc(sizeof(*eb) + alloc_size, GFP_NOFS);
387                 BUG_ON(!new_eb);
388                 new_eb->dev_bytenr = multi->stripes[i].physical;
389                 new_eb->fd = multi->stripes[i].dev->fd;
390                 multi->stripes[i].dev->total_ios++;
391                 new_eb->len = stripe_len;
392
393                 if (raid_map[i] == BTRFS_RAID5_P_STRIPE)
394                         p_eb = new_eb;
395                 else if (raid_map[i] == BTRFS_RAID6_Q_STRIPE)
396                         q_eb = new_eb;
397         }
398         if (q_eb) {
399                 void *pointers[multi->num_stripes];
400                 ebs[multi->num_stripes - 2] = p_eb;
401                 ebs[multi->num_stripes - 1] = q_eb;
402
403                 for (i = 0; i < multi->num_stripes; i++)
404                         pointers[i] = ebs[i]->data;
405
406                 raid6_gen_syndrome(multi->num_stripes, stripe_len, pointers);
407         } else {
408                 ebs[multi->num_stripes - 1] = p_eb;
409                 memcpy(p_eb->data, ebs[0]->data, stripe_len);
410                 for (j = 1; j < multi->num_stripes - 1; j++) {
411                         for (i = 0; i < stripe_len; i += sizeof(unsigned long)) {
412                                 *(unsigned long *)(p_eb->data + i) ^=
413                                         *(unsigned long *)(ebs[j]->data + i);
414                         }
415                 }
416         }
417
418         for (i = 0; i < multi->num_stripes; i++) {
419                 ret = write_extent_to_disk(ebs[i]);
420                 BUG_ON(ret);
421                 if (ebs[i] != eb)
422                         kfree(ebs[i]);
423         }
424         return 0;
425 }
426
427 int write_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
428                      struct extent_buffer *eb)
429 {
430         int ret;
431         int dev_nr;
432         u64 length;
433         u64 *raid_map = NULL;
434         struct btrfs_multi_bio *multi = NULL;
435
436         if (check_tree_block(root, eb))
437                 BUG();
438         if (!btrfs_buffer_uptodate(eb, trans->transid))
439                 BUG();
440
441         btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
442         csum_tree_block(root, eb, 0);
443
444         dev_nr = 0;
445         length = eb->len;
446         ret = btrfs_map_block(&root->fs_info->mapping_tree, WRITE,
447                               eb->start, &length, &multi, 0, &raid_map);
448
449         if (raid_map) {
450                 ret = write_raid56_with_parity(root->fs_info, eb, multi,
451                                                length, raid_map);
452                 BUG_ON(ret);
453         } else while (dev_nr < multi->num_stripes) {
454                 BUG_ON(ret);
455                 eb->fd = multi->stripes[dev_nr].dev->fd;
456                 eb->dev_bytenr = multi->stripes[dev_nr].physical;
457                 multi->stripes[dev_nr].dev->total_ios++;
458                 dev_nr++;
459                 ret = write_extent_to_disk(eb);
460                 BUG_ON(ret);
461         }
462         kfree(multi);
463         return 0;
464 }
465
466 int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
467                         u32 stripesize, struct btrfs_root *root,
468                         struct btrfs_fs_info *fs_info, u64 objectid)
469 {
470         root->node = NULL;
471         root->commit_root = NULL;
472         root->sectorsize = sectorsize;
473         root->nodesize = nodesize;
474         root->leafsize = leafsize;
475         root->stripesize = stripesize;
476         root->ref_cows = 0;
477         root->track_dirty = 0;
478
479         root->fs_info = fs_info;
480         root->objectid = objectid;
481         root->last_trans = 0;
482         root->highest_inode = 0;
483         root->last_inode_alloc = 0;
484
485         INIT_LIST_HEAD(&root->dirty_list);
486         memset(&root->root_key, 0, sizeof(root->root_key));
487         memset(&root->root_item, 0, sizeof(root->root_item));
488         root->root_key.objectid = objectid;
489         return 0;
490 }
491
492 static int update_cowonly_root(struct btrfs_trans_handle *trans,
493                                struct btrfs_root *root)
494 {
495         int ret;
496         u64 old_root_bytenr;
497         struct btrfs_root *tree_root = root->fs_info->tree_root;
498
499         btrfs_write_dirty_block_groups(trans, root);
500         while(1) {
501                 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
502                 if (old_root_bytenr == root->node->start)
503                         break;
504                 btrfs_set_root_bytenr(&root->root_item,
505                                        root->node->start);
506                 btrfs_set_root_generation(&root->root_item,
507                                           trans->transid);
508                 root->root_item.level = btrfs_header_level(root->node);
509                 ret = btrfs_update_root(trans, tree_root,
510                                         &root->root_key,
511                                         &root->root_item);
512                 BUG_ON(ret);
513                 btrfs_write_dirty_block_groups(trans, root);
514         }
515         return 0;
516 }
517
518 static int commit_tree_roots(struct btrfs_trans_handle *trans,
519                              struct btrfs_fs_info *fs_info)
520 {
521         struct btrfs_root *root;
522         struct list_head *next;
523         struct extent_buffer *eb;
524         int ret;
525
526         if (fs_info->readonly)
527                 return 0;
528
529         eb = fs_info->tree_root->node;
530         extent_buffer_get(eb);
531         ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
532         free_extent_buffer(eb);
533         if (ret)
534                 return ret;
535
536         while(!list_empty(&fs_info->dirty_cowonly_roots)) {
537                 next = fs_info->dirty_cowonly_roots.next;
538                 list_del_init(next);
539                 root = list_entry(next, struct btrfs_root, dirty_list);
540                 update_cowonly_root(trans, root);
541         }
542         return 0;
543 }
544
545 static int __commit_transaction(struct btrfs_trans_handle *trans,
546                                 struct btrfs_root *root)
547 {
548         u64 start;
549         u64 end;
550         struct extent_buffer *eb;
551         struct extent_io_tree *tree = &root->fs_info->extent_cache;
552         int ret;
553
554         while(1) {
555                 ret = find_first_extent_bit(tree, 0, &start, &end,
556                                             EXTENT_DIRTY);
557                 if (ret)
558                         break;
559                 while(start <= end) {
560                         eb = find_first_extent_buffer(tree, start);
561                         BUG_ON(!eb || eb->start != start);
562                         ret = write_tree_block(trans, root, eb);
563                         BUG_ON(ret);
564                         start += eb->len;
565                         clear_extent_buffer_dirty(eb);
566                         free_extent_buffer(eb);
567                 }
568         }
569         return 0;
570 }
571
572 int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
573                              struct btrfs_root *root)
574 {
575         u64 transid = trans->transid;
576         int ret = 0;
577         struct btrfs_fs_info *fs_info = root->fs_info;
578
579         if (root->commit_root == root->node)
580                 goto commit_tree;
581
582         free_extent_buffer(root->commit_root);
583         root->commit_root = NULL;
584
585         btrfs_set_root_bytenr(&root->root_item, root->node->start);
586         btrfs_set_root_generation(&root->root_item, trans->transid);
587         root->root_item.level = btrfs_header_level(root->node);
588         ret = btrfs_update_root(trans, root->fs_info->tree_root,
589                                 &root->root_key, &root->root_item);
590         BUG_ON(ret);
591 commit_tree:
592         ret = commit_tree_roots(trans, fs_info);
593         BUG_ON(ret);
594         ret = __commit_transaction(trans, root);
595         BUG_ON(ret);
596         write_ctree_super(trans, root);
597         btrfs_finish_extent_commit(trans, fs_info->extent_root,
598                                    &fs_info->pinned_extents);
599         btrfs_free_transaction(root, trans);
600         free_extent_buffer(root->commit_root);
601         root->commit_root = NULL;
602         fs_info->running_transaction = NULL;
603         fs_info->last_trans_committed = transid;
604         return 0;
605 }
606
607 static int find_and_setup_root(struct btrfs_root *tree_root,
608                                struct btrfs_fs_info *fs_info,
609                                u64 objectid, struct btrfs_root *root)
610 {
611         int ret;
612         u32 blocksize;
613         u64 generation;
614
615         __setup_root(tree_root->nodesize, tree_root->leafsize,
616                      tree_root->sectorsize, tree_root->stripesize,
617                      root, fs_info, objectid);
618         ret = btrfs_find_last_root(tree_root, objectid,
619                                    &root->root_item, &root->root_key);
620         if (ret)
621                 return ret;
622
623         blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
624         generation = btrfs_root_generation(&root->root_item);
625         root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
626                                      blocksize, generation);
627         if (!extent_buffer_uptodate(root->node))
628                 return -EIO;
629
630         return 0;
631 }
632
633 static int find_and_setup_log_root(struct btrfs_root *tree_root,
634                                struct btrfs_fs_info *fs_info,
635                                struct btrfs_super_block *disk_super)
636 {
637         u32 blocksize;
638         u64 blocknr = btrfs_super_log_root(disk_super);
639         struct btrfs_root *log_root = malloc(sizeof(struct btrfs_root));
640
641         if (!log_root)
642                 return -ENOMEM;
643
644         if (blocknr == 0) {
645                 free(log_root);
646                 return 0;
647         }
648
649         blocksize = btrfs_level_size(tree_root,
650                              btrfs_super_log_root_level(disk_super));
651
652         __setup_root(tree_root->nodesize, tree_root->leafsize,
653                      tree_root->sectorsize, tree_root->stripesize,
654                      log_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
655
656         log_root->node = read_tree_block(tree_root, blocknr,
657                                      blocksize,
658                                      btrfs_super_generation(disk_super) + 1);
659
660         fs_info->log_root_tree = log_root;
661
662         if (!extent_buffer_uptodate(log_root->node)) {
663                 free_extent_buffer(log_root->node);
664                 free(log_root);
665                 fs_info->log_root_tree = NULL;
666                 return -EIO;
667         }
668
669         return 0;
670 }
671
672
673 int btrfs_free_fs_root(struct btrfs_fs_info *fs_info,
674                        struct btrfs_root *root)
675 {
676         if (root->node)
677                 free_extent_buffer(root->node);
678         if (root->commit_root)
679                 free_extent_buffer(root->commit_root);
680         kfree(root);
681         return 0;
682 }
683
684 static int free_fs_roots(struct btrfs_fs_info *fs_info)
685 {
686         struct cache_extent *cache;
687         struct btrfs_root *root;
688
689         while (1) {
690                 cache = find_first_cache_extent(&fs_info->fs_root_cache, 0);
691                 if (!cache)
692                         break;
693                 root = container_of(cache, struct btrfs_root, cache);
694                 remove_cache_extent(&fs_info->fs_root_cache, cache);
695                 btrfs_free_fs_root(fs_info, root);
696         }
697         return 0;
698 }
699
700 struct btrfs_root *btrfs_read_fs_root_no_cache(struct btrfs_fs_info *fs_info,
701                                                struct btrfs_key *location)
702 {
703         struct btrfs_root *root;
704         struct btrfs_root *tree_root = fs_info->tree_root;
705         struct btrfs_path *path;
706         struct extent_buffer *l;
707         u64 generation;
708         u32 blocksize;
709         int ret = 0;
710
711         root = malloc(sizeof(*root));
712         if (!root)
713                 return ERR_PTR(-ENOMEM);
714         memset(root, 0, sizeof(*root));
715         if (location->offset == (u64)-1) {
716                 ret = find_and_setup_root(tree_root, fs_info,
717                                           location->objectid, root);
718                 if (ret) {
719                         free(root);
720                         return ERR_PTR(ret);
721                 }
722                 goto insert;
723         }
724
725         __setup_root(tree_root->nodesize, tree_root->leafsize,
726                      tree_root->sectorsize, tree_root->stripesize,
727                      root, fs_info, location->objectid);
728
729         path = btrfs_alloc_path();
730         BUG_ON(!path);
731         ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
732         if (ret != 0) {
733                 if (ret > 0)
734                         ret = -ENOENT;
735                 goto out;
736         }
737         l = path->nodes[0];
738         read_extent_buffer(l, &root->root_item,
739                btrfs_item_ptr_offset(l, path->slots[0]),
740                sizeof(root->root_item));
741         memcpy(&root->root_key, location, sizeof(*location));
742         ret = 0;
743 out:
744         btrfs_release_path(root, path);
745         btrfs_free_path(path);
746         if (ret) {
747                 free(root);
748                 return ERR_PTR(ret);
749         }
750         generation = btrfs_root_generation(&root->root_item);
751         blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
752         root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
753                                      blocksize, generation);
754         BUG_ON(!root->node);
755 insert:
756         root->ref_cows = 1;
757         return root;
758 }
759
760 struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
761                                       struct btrfs_key *location)
762 {
763         struct btrfs_root *root;
764         struct cache_extent *cache;
765         int ret;
766
767         if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
768                 return fs_info->tree_root;
769         if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
770                 return fs_info->extent_root;
771         if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
772                 return fs_info->chunk_root;
773         if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
774                 return fs_info->dev_root;
775         if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
776                 return fs_info->csum_root;
777
778         BUG_ON(location->objectid == BTRFS_TREE_RELOC_OBJECTID ||
779                location->offset != (u64)-1);
780
781         cache = find_cache_extent(&fs_info->fs_root_cache,
782                                   location->objectid, 1);
783         if (cache)
784                 return container_of(cache, struct btrfs_root, cache);
785
786         root = btrfs_read_fs_root_no_cache(fs_info, location);
787         if (IS_ERR(root))
788                 return root;
789
790         root->cache.start = location->objectid;
791         root->cache.size = 1;
792         ret = insert_existing_cache_extent(&fs_info->fs_root_cache,
793                                            &root->cache);
794         BUG_ON(ret);
795         return root;
796 }
797
798 static struct btrfs_fs_info *__open_ctree_fd(int fp, const char *path,
799                                              u64 sb_bytenr,
800                                              u64 root_tree_bytenr, int writes,
801                                              int partial)
802 {
803         u32 sectorsize;
804         u32 nodesize;
805         u32 leafsize;
806         u32 blocksize;
807         u32 stripesize;
808         u64 generation;
809         struct btrfs_key key;
810         struct btrfs_root *tree_root = malloc(sizeof(struct btrfs_root));
811         struct btrfs_root *extent_root = malloc(sizeof(struct btrfs_root));
812         struct btrfs_root *chunk_root = malloc(sizeof(struct btrfs_root));
813         struct btrfs_root *dev_root = malloc(sizeof(struct btrfs_root));
814         struct btrfs_root *csum_root = malloc(sizeof(struct btrfs_root));
815         struct btrfs_fs_info *fs_info = malloc(sizeof(*fs_info));
816         int ret;
817         struct btrfs_super_block *disk_super;
818         struct btrfs_fs_devices *fs_devices = NULL;
819         u64 total_devs;
820         u64 features;
821
822         if (sb_bytenr == 0)
823                 sb_bytenr = BTRFS_SUPER_INFO_OFFSET;
824
825         /* try to drop all the caches */
826         if (posix_fadvise(fp, 0, 0, POSIX_FADV_DONTNEED))
827                 fprintf(stderr, "Warning, could not drop caches\n");
828
829         ret = btrfs_scan_one_device(fp, path, &fs_devices,
830                                     &total_devs, sb_bytenr);
831
832         if (ret) {
833                 fprintf(stderr, "No valid Btrfs found on %s\n", path);
834                 goto out;
835         }
836
837         if (total_devs != 1) {
838                 ret = btrfs_scan_for_fsid(fs_devices, total_devs, 1);
839                 if (ret)
840                         goto out;
841         }
842
843         memset(fs_info, 0, sizeof(*fs_info));
844         fs_info->super_copy = calloc(1, BTRFS_SUPER_INFO_SIZE);
845         fs_info->tree_root = tree_root;
846         fs_info->extent_root = extent_root;
847         fs_info->chunk_root = chunk_root;
848         fs_info->dev_root = dev_root;
849         fs_info->csum_root = csum_root;
850
851         if (!writes)
852                 fs_info->readonly = 1;
853
854         extent_io_tree_init(&fs_info->extent_cache);
855         extent_io_tree_init(&fs_info->free_space_cache);
856         extent_io_tree_init(&fs_info->block_group_cache);
857         extent_io_tree_init(&fs_info->pinned_extents);
858         extent_io_tree_init(&fs_info->pending_del);
859         extent_io_tree_init(&fs_info->extent_ins);
860         cache_tree_init(&fs_info->fs_root_cache);
861
862         cache_tree_init(&fs_info->mapping_tree.cache_tree);
863
864         mutex_init(&fs_info->fs_mutex);
865         fs_info->fs_devices = fs_devices;
866         INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
867         INIT_LIST_HEAD(&fs_info->space_info);
868
869         __setup_root(4096, 4096, 4096, 4096, tree_root,
870                      fs_info, BTRFS_ROOT_TREE_OBJECTID);
871
872         if (writes)
873                 ret = btrfs_open_devices(fs_devices, O_RDWR);
874         else
875                 ret = btrfs_open_devices(fs_devices, O_RDONLY);
876         if (ret)
877                 goto out_cleanup;
878
879         fs_info->super_bytenr = sb_bytenr;
880         disk_super = fs_info->super_copy;
881         ret = btrfs_read_dev_super(fs_devices->latest_bdev,
882                                    disk_super, sb_bytenr);
883         if (ret) {
884                 printk("No valid btrfs found\n");
885                 goto out_devices;
886         }
887
888         memcpy(fs_info->fsid, &disk_super->fsid, BTRFS_FSID_SIZE);
889
890
891         features = btrfs_super_incompat_flags(disk_super) &
892                    ~BTRFS_FEATURE_INCOMPAT_SUPP;
893         if (features) {
894                 printk("couldn't open because of unsupported "
895                        "option features (%Lx).\n",
896                        (unsigned long long)features);
897                 goto out_devices;
898         }
899
900         features = btrfs_super_incompat_flags(disk_super);
901         if (!(features & BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF)) {
902                 features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
903                 btrfs_set_super_incompat_flags(disk_super, features);
904         }
905
906         features = btrfs_super_compat_ro_flags(disk_super) &
907                 ~BTRFS_FEATURE_COMPAT_RO_SUPP;
908         if (writes && features) {
909                 printk("couldn't open RDWR because of unsupported "
910                        "option features (%Lx).\n",
911                        (unsigned long long)features);
912                 goto out_devices;
913         }
914
915         nodesize = btrfs_super_nodesize(disk_super);
916         leafsize = btrfs_super_leafsize(disk_super);
917         sectorsize = btrfs_super_sectorsize(disk_super);
918         stripesize = btrfs_super_stripesize(disk_super);
919         tree_root->nodesize = nodesize;
920         tree_root->leafsize = leafsize;
921         tree_root->sectorsize = sectorsize;
922         tree_root->stripesize = stripesize;
923
924         ret = btrfs_read_sys_array(tree_root);
925         if (ret)
926                 goto out_devices;
927         blocksize = btrfs_level_size(tree_root,
928                                      btrfs_super_chunk_root_level(disk_super));
929         generation = btrfs_super_chunk_root_generation(disk_super);
930
931         __setup_root(nodesize, leafsize, sectorsize, stripesize,
932                      chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
933
934         chunk_root->node = read_tree_block(chunk_root,
935                                            btrfs_super_chunk_root(disk_super),
936                                            blocksize, generation);
937         if (!extent_buffer_uptodate(chunk_root->node)) {
938                 printk("Couldn't read chunk root\n");
939                 goto out_devices;
940         }
941
942         read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
943                  (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
944                  BTRFS_UUID_SIZE);
945
946         if (!(btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_METADUMP)) {
947                 ret = btrfs_read_chunk_tree(chunk_root);
948                 if (ret) {
949                         printk("Couldn't read chunk tree\n");
950                         goto out_chunk;
951                 }
952         }
953
954         blocksize = btrfs_level_size(tree_root,
955                                      btrfs_super_root_level(disk_super));
956         generation = btrfs_super_generation(disk_super);
957
958         if (!root_tree_bytenr)
959                 root_tree_bytenr = btrfs_super_root(disk_super);
960         tree_root->node = read_tree_block(tree_root,
961                                           root_tree_bytenr,
962                                           blocksize, generation);
963         if (!extent_buffer_uptodate(tree_root->node)) {
964                 printk("Couldn't read tree root\n");
965                 goto out_failed;
966         }
967         ret = find_and_setup_root(tree_root, fs_info,
968                                   BTRFS_EXTENT_TREE_OBJECTID, extent_root);
969         if (ret) {
970                 printk("Couldn't setup extent tree\n");
971                 goto out_failed;
972         }
973         extent_root->track_dirty = 1;
974
975         ret = find_and_setup_root(tree_root, fs_info,
976                                   BTRFS_DEV_TREE_OBJECTID, dev_root);
977         if (ret) {
978                 printk("Couldn't setup device tree\n");
979                 goto out_failed;
980         }
981         dev_root->track_dirty = 1;
982
983         ret = find_and_setup_root(tree_root, fs_info,
984                                   BTRFS_CSUM_TREE_OBJECTID, csum_root);
985         if (ret) {
986                 printk("Couldn't setup csum tree\n");
987                 if (!partial)
988                         goto out_failed;
989         }
990         csum_root->track_dirty = 1;
991
992         find_and_setup_log_root(tree_root, fs_info, disk_super);
993
994         fs_info->generation = generation;
995         fs_info->last_trans_committed = generation;
996         btrfs_read_block_groups(fs_info->tree_root);
997
998         key.objectid = BTRFS_FS_TREE_OBJECTID;
999         key.type = BTRFS_ROOT_ITEM_KEY;
1000         key.offset = (u64)-1;
1001         fs_info->fs_root = btrfs_read_fs_root(fs_info, &key);
1002
1003         if (!fs_info->fs_root)
1004                 goto out_failed;
1005
1006         fs_info->data_alloc_profile = (u64)-1;
1007         fs_info->metadata_alloc_profile = (u64)-1;
1008         fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;
1009
1010         return fs_info;
1011
1012 out_failed:
1013         if (partial)
1014                 return fs_info;
1015
1016         if (fs_info->csum_root)
1017                 free_extent_buffer(fs_info->csum_root->node);
1018         if (fs_info->dev_root)
1019                 free_extent_buffer(fs_info->dev_root->node);
1020         if (fs_info->extent_root)
1021                 free_extent_buffer(fs_info->extent_root->node);
1022         if (fs_info->tree_root)
1023                 free_extent_buffer(fs_info->tree_root->node);
1024 out_chunk:
1025         if (fs_info->chunk_root)
1026                 free_extent_buffer(fs_info->chunk_root->node);
1027 out_devices:
1028         close_all_devices(fs_info);
1029 out_cleanup:
1030         extent_io_tree_cleanup(&fs_info->extent_cache);
1031         extent_io_tree_cleanup(&fs_info->free_space_cache);
1032         extent_io_tree_cleanup(&fs_info->block_group_cache);
1033         extent_io_tree_cleanup(&fs_info->pinned_extents);
1034         extent_io_tree_cleanup(&fs_info->pending_del);
1035         extent_io_tree_cleanup(&fs_info->extent_ins);
1036 out:
1037         free(tree_root);
1038         free(extent_root);
1039         free(chunk_root);
1040         free(dev_root);
1041         free(csum_root);
1042         free(fs_info);
1043         return NULL;
1044 }
1045
1046 struct btrfs_fs_info *open_ctree_fs_info(const char *filename,
1047                                          u64 sb_bytenr, u64 root_tree_bytenr,
1048                                          int writes, int partial)
1049 {
1050         int fp;
1051         struct btrfs_fs_info *info;
1052         int flags = O_CREAT | O_RDWR;
1053
1054         if (!writes)
1055                 flags = O_RDONLY;
1056
1057         fp = open(filename, flags, 0600);
1058         if (fp < 0) {
1059                 fprintf (stderr, "Could not open %s\n", filename);
1060                 return NULL;
1061         }
1062         info = __open_ctree_fd(fp, filename, sb_bytenr, root_tree_bytenr,
1063                                writes, partial);
1064         close(fp);
1065         return info;
1066 }
1067
1068 struct btrfs_root *open_ctree(const char *filename, u64 sb_bytenr, int writes)
1069 {
1070         struct btrfs_fs_info *info;
1071
1072         info = open_ctree_fs_info(filename, sb_bytenr, 0, writes, 0);
1073         if (!info)
1074                 return NULL;
1075         return info->fs_root;
1076 }
1077
1078 struct btrfs_root *open_ctree_fd(int fp, const char *path, u64 sb_bytenr,
1079                                  int writes)
1080 {
1081         struct btrfs_fs_info *info;
1082         info = __open_ctree_fd(fp, path, sb_bytenr, 0, writes, 0);
1083         if (!info)
1084                 return NULL;
1085         return info->fs_root;
1086 }
1087
1088 int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr)
1089 {
1090         u8 fsid[BTRFS_FSID_SIZE];
1091         int fsid_is_initialized = 0;
1092         struct btrfs_super_block buf;
1093         int i;
1094         int ret;
1095         u64 transid = 0;
1096         u64 bytenr;
1097
1098         if (sb_bytenr != BTRFS_SUPER_INFO_OFFSET) {
1099                 ret = pread64(fd, &buf, sizeof(buf), sb_bytenr);
1100                 if (ret < sizeof(buf))
1101                         return -1;
1102
1103                 if (btrfs_super_bytenr(&buf) != sb_bytenr ||
1104                     buf.magic != cpu_to_le64(BTRFS_MAGIC))
1105                         return -1;
1106
1107                 memcpy(sb, &buf, sizeof(*sb));
1108                 return 0;
1109         }
1110
1111         for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
1112                 bytenr = btrfs_sb_offset(i);
1113                 ret = pread64(fd, &buf, sizeof(buf), bytenr);
1114                 if (ret < sizeof(buf))
1115                         break;
1116
1117                 if (btrfs_super_bytenr(&buf) != bytenr )
1118                         continue;
1119                 /* if magic is NULL, the device was removed */
1120                 if (buf.magic == 0 && i == 0) 
1121                         return -1;
1122                 if (buf.magic != cpu_to_le64(BTRFS_MAGIC))
1123                         continue;
1124
1125                 if (!fsid_is_initialized) {
1126                         memcpy(fsid, buf.fsid, sizeof(fsid));
1127                         fsid_is_initialized = 1;
1128                 } else if (memcmp(fsid, buf.fsid, sizeof(fsid))) {
1129                         /*
1130                          * the superblocks (the original one and
1131                          * its backups) contain data of different
1132                          * filesystems -> the super cannot be trusted
1133                          */
1134                         continue;
1135                 }
1136
1137                 if (btrfs_super_generation(&buf) > transid) {
1138                         memcpy(sb, &buf, sizeof(*sb));
1139                         transid = btrfs_super_generation(&buf);
1140                 }
1141         }
1142
1143         return transid > 0 ? 0 : -1;
1144 }
1145
1146 int write_dev_supers(struct btrfs_root *root, struct btrfs_super_block *sb,
1147                      struct btrfs_device *device)
1148 {
1149         u64 bytenr;
1150         u32 crc;
1151         int i, ret;
1152
1153         if (root->fs_info->super_bytenr != BTRFS_SUPER_INFO_OFFSET) {
1154                 btrfs_set_super_bytenr(sb, root->fs_info->super_bytenr);
1155                 crc = ~(u32)0;
1156                 crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc,
1157                                       BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
1158                 btrfs_csum_final(crc, (char *)&sb->csum[0]);
1159
1160                 /*
1161                  * super_copy is BTRFS_SUPER_INFO_SIZE bytes and is
1162                  * zero filled, we can use it directly
1163                  */
1164                 ret = pwrite64(device->fd, root->fs_info->super_copy,
1165                                 BTRFS_SUPER_INFO_SIZE,
1166                                 root->fs_info->super_bytenr);
1167                 BUG_ON(ret != BTRFS_SUPER_INFO_SIZE);
1168                 return 0;
1169         }
1170
1171         for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
1172                 bytenr = btrfs_sb_offset(i);
1173                 if (bytenr + BTRFS_SUPER_INFO_SIZE > device->total_bytes)
1174                         break;
1175
1176                 btrfs_set_super_bytenr(sb, bytenr);
1177
1178                 crc = ~(u32)0;
1179                 crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc,
1180                                       BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
1181                 btrfs_csum_final(crc, (char *)&sb->csum[0]);
1182
1183                 /*
1184                  * super_copy is BTRFS_SUPER_INFO_SIZE bytes and is
1185                  * zero filled, we can use it directly
1186                  */
1187                 ret = pwrite64(device->fd, root->fs_info->super_copy,
1188                                 BTRFS_SUPER_INFO_SIZE, bytenr);
1189                 BUG_ON(ret != BTRFS_SUPER_INFO_SIZE);
1190         }
1191
1192         return 0;
1193 }
1194
1195 int write_all_supers(struct btrfs_root *root)
1196 {
1197         struct list_head *cur;
1198         struct list_head *head = &root->fs_info->fs_devices->devices;
1199         struct btrfs_device *dev;
1200         struct btrfs_super_block *sb;
1201         struct btrfs_dev_item *dev_item;
1202         int ret;
1203         u64 flags;
1204
1205         sb = root->fs_info->super_copy;
1206         dev_item = &sb->dev_item;
1207         list_for_each(cur, head) {
1208                 dev = list_entry(cur, struct btrfs_device, dev_list);
1209                 if (!dev->writeable)
1210                         continue;
1211
1212                 btrfs_set_stack_device_generation(dev_item, 0);
1213                 btrfs_set_stack_device_type(dev_item, dev->type);
1214                 btrfs_set_stack_device_id(dev_item, dev->devid);
1215                 btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);
1216                 btrfs_set_stack_device_bytes_used(dev_item, dev->bytes_used);
1217                 btrfs_set_stack_device_io_align(dev_item, dev->io_align);
1218                 btrfs_set_stack_device_io_width(dev_item, dev->io_width);
1219                 btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
1220                 memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
1221                 memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
1222
1223                 flags = btrfs_super_flags(sb);
1224                 btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
1225
1226                 ret = write_dev_supers(root, sb, dev);
1227                 BUG_ON(ret);
1228         }
1229         return 0;
1230 }
1231
1232 int write_ctree_super(struct btrfs_trans_handle *trans,
1233                       struct btrfs_root *root)
1234 {
1235         int ret;
1236         struct btrfs_root *tree_root = root->fs_info->tree_root;
1237         struct btrfs_root *chunk_root = root->fs_info->chunk_root;
1238
1239         if (root->fs_info->readonly)
1240                 return 0;
1241
1242         btrfs_set_super_generation(root->fs_info->super_copy,
1243                                    trans->transid);
1244         btrfs_set_super_root(root->fs_info->super_copy,
1245                              tree_root->node->start);
1246         btrfs_set_super_root_level(root->fs_info->super_copy,
1247                                    btrfs_header_level(tree_root->node));
1248         btrfs_set_super_chunk_root(root->fs_info->super_copy,
1249                                    chunk_root->node->start);
1250         btrfs_set_super_chunk_root_level(root->fs_info->super_copy,
1251                                          btrfs_header_level(chunk_root->node));
1252         btrfs_set_super_chunk_root_generation(root->fs_info->super_copy,
1253                                 btrfs_header_generation(chunk_root->node));
1254
1255         ret = write_all_supers(root);
1256         if (ret)
1257                 fprintf(stderr, "failed to write new super block err %d\n", ret);
1258         return ret;
1259 }
1260
1261 static int close_all_devices(struct btrfs_fs_info *fs_info)
1262 {
1263         struct list_head *list;
1264         struct btrfs_device *device;
1265
1266         list = &fs_info->fs_devices->devices;
1267         while (!list_empty(list)) {
1268                 device = list_entry(list->next, struct btrfs_device, dev_list);
1269                 list_del_init(&device->dev_list);
1270                 if (device->fd) {
1271                         fsync(device->fd);
1272                         if (posix_fadvise(device->fd, 0, 0, POSIX_FADV_DONTNEED))
1273                                 fprintf(stderr, "Warning, could not drop caches\n");
1274                 }
1275                 close(device->fd);
1276                 kfree(device->name);
1277                 kfree(device->label);
1278                 kfree(device);
1279         }
1280         kfree(fs_info->fs_devices);
1281         return 0;
1282 }
1283
1284 static void free_mapping_cache(struct btrfs_fs_info *fs_info)
1285 {
1286         struct cache_tree *cache_tree = &fs_info->mapping_tree.cache_tree;
1287         struct cache_extent *ce;
1288         struct map_lookup *map;
1289
1290         while ((ce = find_first_cache_extent(cache_tree, 0))) {
1291                 map = container_of(ce, struct map_lookup, ce);
1292                 remove_cache_extent(cache_tree, ce);
1293                 kfree(map);
1294         }
1295 }
1296
1297 int close_ctree(struct btrfs_root *root)
1298 {
1299         int ret;
1300         struct btrfs_trans_handle *trans;
1301         struct btrfs_fs_info *fs_info = root->fs_info;
1302
1303         if (fs_info->last_trans_committed !=
1304             fs_info->generation) {
1305                 trans = btrfs_start_transaction(root, 1);
1306                 btrfs_commit_transaction(trans, root);
1307                 trans = btrfs_start_transaction(root, 1);
1308                 ret = commit_tree_roots(trans, fs_info);
1309                 BUG_ON(ret);
1310                 ret = __commit_transaction(trans, root);
1311                 BUG_ON(ret);
1312                 write_ctree_super(trans, root);
1313                 btrfs_free_transaction(root, trans);
1314         }
1315         btrfs_free_block_groups(fs_info);
1316
1317         free_fs_roots(fs_info);
1318
1319         if (fs_info->extent_root->node)
1320                 free_extent_buffer(fs_info->extent_root->node);
1321         if (fs_info->tree_root->node)
1322                 free_extent_buffer(fs_info->tree_root->node);
1323         if (fs_info->chunk_root->node)
1324                 free_extent_buffer(fs_info->chunk_root->node);
1325         if (fs_info->dev_root->node)
1326                 free_extent_buffer(fs_info->dev_root->node);
1327         if (fs_info->csum_root->node)
1328                 free_extent_buffer(fs_info->csum_root->node);
1329
1330         if (fs_info->log_root_tree) {
1331                 if (fs_info->log_root_tree->node)
1332                         free_extent_buffer(fs_info->log_root_tree->node);
1333                 free(fs_info->log_root_tree);
1334         }
1335
1336         close_all_devices(fs_info);
1337         free_mapping_cache(fs_info);
1338         extent_io_tree_cleanup(&fs_info->extent_cache);
1339         extent_io_tree_cleanup(&fs_info->free_space_cache);
1340         extent_io_tree_cleanup(&fs_info->block_group_cache);
1341         extent_io_tree_cleanup(&fs_info->pinned_extents);
1342         extent_io_tree_cleanup(&fs_info->pending_del);
1343         extent_io_tree_cleanup(&fs_info->extent_ins);
1344
1345         free(fs_info->tree_root);
1346         free(fs_info->extent_root);
1347         free(fs_info->chunk_root);
1348         free(fs_info->dev_root);
1349         free(fs_info->csum_root);
1350         free(fs_info);
1351
1352         return 0;
1353 }
1354
1355 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1356                      struct extent_buffer *eb)
1357 {
1358         return clear_extent_buffer_dirty(eb);
1359 }
1360
1361 int wait_on_tree_block_writeback(struct btrfs_root *root,
1362                                  struct extent_buffer *eb)
1363 {
1364         return 0;
1365 }
1366
1367 void btrfs_mark_buffer_dirty(struct extent_buffer *eb)
1368 {
1369         set_extent_buffer_dirty(eb);
1370 }
1371
1372 int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid)
1373 {
1374         int ret;
1375
1376         ret = extent_buffer_uptodate(buf);
1377         if (!ret)
1378                 return ret;
1379
1380         ret = verify_parent_transid(buf->tree, buf, parent_transid, 1);
1381         return !ret;
1382 }
1383
1384 int btrfs_set_buffer_uptodate(struct extent_buffer *eb)
1385 {
1386         return set_extent_buffer_uptodate(eb);
1387 }