?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Btrfs progs v4.9.1
[btrfs-progs-unstable/devel.git] / disk-io.c
blob2a94d4fc2131bb814287c7b703df561054a094fe
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 #include <stdio.h>
20 #include <stdlib.h>
21 #include <sys/types.h>
22 #include <sys/stat.h>
23 #include <fcntl.h>
24 #include <unistd.h>
25 #include <uuid/uuid.h>
26 #include "kerncompat.h"
27 #include "radix-tree.h"
28 #include "ctree.h"
29 #include "disk-io.h"
30 #include "volumes.h"
31 #include "transaction.h"
32 #include "crc32c.h"
33 #include "utils.h"
34 #include "print-tree.h"
35 #include "rbtree-utils.h"
36
37 /* specified errno for check_tree_block */
38 #define BTRFS_BAD_BYTENR (-1)
39 #define BTRFS_BAD_FSID (-2)
40 #define BTRFS_BAD_LEVEL (-3)
41 #define BTRFS_BAD_NRITEMS (-4)
42
43 /* Calculate max possible nritems for a leaf/node */
44 static u32 max_nritems(u8 level, u32 nodesize)
45 {
46
47 if (level == 0)
48 return ((nodesize - sizeof(struct btrfs_header)) /
49 sizeof(struct btrfs_item));
50 return ((nodesize - sizeof(struct btrfs_header)) /
51 sizeof(struct btrfs_key_ptr));
52 }
53
54 static int check_tree_block(struct btrfs_fs_info *fs_info,
55 struct extent_buffer *buf)
56 {
57
58 struct btrfs_fs_devices *fs_devices;
59 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
60 int ret = BTRFS_BAD_FSID;
61
62 if (buf->start != btrfs_header_bytenr(buf))
63 return BTRFS_BAD_BYTENR;
64 if (btrfs_header_level(buf) >= BTRFS_MAX_LEVEL)
65 return BTRFS_BAD_LEVEL;
66 if (btrfs_header_nritems(buf) > max_nritems(btrfs_header_level(buf),
67 nodesize))
68 return BTRFS_BAD_NRITEMS;
69
70 /* Only leaf can be empty */
71 if (btrfs_header_nritems(buf) == 0 &&
72 btrfs_header_level(buf) != 0)
73 return BTRFS_BAD_NRITEMS;
74
75 fs_devices = fs_info->fs_devices;
76 while (fs_devices) {
77 if (fs_info->ignore_fsid_mismatch ||
78 !memcmp_extent_buffer(buf, fs_devices->fsid,
79 btrfs_header_fsid(),
80 BTRFS_FSID_SIZE)) {
81 ret = 0;
82 break;
83 }
84 fs_devices = fs_devices->seed;
85 }
86 return ret;
87 }
88
89 static void print_tree_block_error(struct btrfs_fs_info *fs_info,
90 struct extent_buffer *eb,
91 int err)
92 {
93 char fs_uuid[BTRFS_UUID_UNPARSED_SIZE] = {'\0'};
94 char found_uuid[BTRFS_UUID_UNPARSED_SIZE] = {'\0'};
95 u8 buf[BTRFS_UUID_SIZE];
96
97 switch (err) {
98 case BTRFS_BAD_FSID:
99 read_extent_buffer(eb, buf, btrfs_header_fsid(),
100 BTRFS_UUID_SIZE);
101 uuid_unparse(buf, found_uuid);
102 uuid_unparse(fs_info->fsid, fs_uuid);
103 fprintf(stderr, "fsid mismatch, want=%s, have=%s\n",
104 fs_uuid, found_uuid);
105 break;
106 case BTRFS_BAD_BYTENR:
107 fprintf(stderr, "bytenr mismatch, want=%llu, have=%llu\n",
108 eb->start, btrfs_header_bytenr(eb));
109 break;
110 case BTRFS_BAD_LEVEL:
111 fprintf(stderr, "bad level, %u > %u\n",
112 btrfs_header_level(eb), BTRFS_MAX_LEVEL);
113 break;
114 case BTRFS_BAD_NRITEMS:
115 fprintf(stderr, "invalid nr_items: %u\n",
116 btrfs_header_nritems(eb));
117 break;
118 }
119 }
120
121 u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
122 {
123 return crc32c(seed, data, len);
124 }
125
126 void btrfs_csum_final(u32 crc, u8 *result)
127 {
128 put_unaligned_le32(~crc, result);
129 }
130
131 static int __csum_tree_block_size(struct extent_buffer *buf, u16 csum_size,
132 int verify, int silent)
133 {
134 u8 result[BTRFS_CSUM_SIZE];
135 u32 len;
136 u32 crc = ~(u32)0;
137
138 len = buf->len - BTRFS_CSUM_SIZE;
139 crc = crc32c(crc, buf->data + BTRFS_CSUM_SIZE, len);
140 btrfs_csum_final(crc, result);
141
142 if (verify) {
143 if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
144 if (!silent)
145 printk("checksum verify failed on %llu found %08X wanted %08X\n",
146 (unsigned long long)buf->start,
147 *((u32 *)result),
148 *((u32*)(char *)buf->data));
149 return 1;
150 }
151 } else {
152 write_extent_buffer(buf, result, 0, csum_size);
153 }
154 return 0;
155 }
156
157 int csum_tree_block_size(struct extent_buffer *buf, u16 csum_size, int verify)
158 {
159 return __csum_tree_block_size(buf, csum_size, verify, 0);
160 }
161
162 int verify_tree_block_csum_silent(struct extent_buffer *buf, u16 csum_size)
163 {
164 return __csum_tree_block_size(buf, csum_size, 1, 1);
165 }
166
167 static int csum_tree_block_fs_info(struct btrfs_fs_info *fs_info,
168 struct extent_buffer *buf, int verify)
169 {
170 u16 csum_size =
171 btrfs_super_csum_size(fs_info->super_copy);
172 if (verify && fs_info->suppress_check_block_errors)
173 return verify_tree_block_csum_silent(buf, csum_size);
174 return csum_tree_block_size(buf, csum_size, verify);
175 }
176
177 int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
178 int verify)
179 {
180 return csum_tree_block_fs_info(root->fs_info, buf, verify);
181 }
182
183 struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
184 u64 bytenr, u32 blocksize)
185 {
186 return find_extent_buffer(&root->fs_info->extent_cache,
187 bytenr, blocksize);
188 }
189
190 struct extent_buffer* btrfs_find_create_tree_block(
191 struct btrfs_fs_info *fs_info, u64 bytenr, u32 blocksize)
192 {
193 return alloc_extent_buffer(&fs_info->extent_cache, bytenr, blocksize);
194 }
195
196 void readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
197 u64 parent_transid)
198 {
199 struct extent_buffer *eb;
200 u64 length;
201 struct btrfs_multi_bio *multi = NULL;
202 struct btrfs_device *device;
203
204 eb = btrfs_find_tree_block(root, bytenr, blocksize);
205 if (!(eb && btrfs_buffer_uptodate(eb, parent_transid)) &&
206 !btrfs_map_block(&root->fs_info->mapping_tree, READ,
207 bytenr, &length, &multi, 0, NULL)) {
208 device = multi->stripes[0].dev;
209 device->total_ios++;
210 blocksize = min(blocksize, (u32)(64 * 1024));
211 readahead(device->fd, multi->stripes[0].physical, blocksize);
212 }
213
214 free_extent_buffer(eb);
215 kfree(multi);
216 }
217
218 static int verify_parent_transid(struct extent_io_tree *io_tree,
219 struct extent_buffer *eb, u64 parent_transid,
220 int ignore)
221 {
222 int ret;
223
224 if (!parent_transid || btrfs_header_generation(eb) == parent_transid)
225 return 0;
226
227 if (extent_buffer_uptodate(eb) &&
228 btrfs_header_generation(eb) == parent_transid) {
229 ret = 0;
230 goto out;
231 }
232 printk("parent transid verify failed on %llu wanted %llu found %llu\n",
233 (unsigned long long)eb->start,
234 (unsigned long long)parent_transid,
235 (unsigned long long)btrfs_header_generation(eb));
236 if (ignore) {
237 eb->flags |= EXTENT_BAD_TRANSID;
238 printk("Ignoring transid failure\n");
239 return 0;
240 }
241
242 ret = 1;
243 out:
244 clear_extent_buffer_uptodate(eb);
245 return ret;
246
247 }
248
249
250 int read_whole_eb(struct btrfs_fs_info *info, struct extent_buffer *eb, int mirror)
251 {
252 unsigned long offset = 0;
253 struct btrfs_multi_bio *multi = NULL;
254 struct btrfs_device *device;
255 int ret = 0;
256 u64 read_len;
257 unsigned long bytes_left = eb->len;
258
259 while (bytes_left) {
260 read_len = bytes_left;
261 device = NULL;
262
263 if (!info->on_restoring &&
264 eb->start != BTRFS_SUPER_INFO_OFFSET) {
265 ret = btrfs_map_block(&info->mapping_tree, READ,
266 eb->start + offset, &read_len, &multi,
267 mirror, NULL);
268 if (ret) {
269 printk("Couldn't map the block %Lu\n", eb->start + offset);
270 kfree(multi);
271 return -EIO;
272 }
273 device = multi->stripes[0].dev;
274
275 if (device->fd <= 0) {
276 kfree(multi);
277 return -EIO;
278 }
279
280 eb->fd = device->fd;
281 device->total_ios++;
282 eb->dev_bytenr = multi->stripes[0].physical;
283 kfree(multi);
284 multi = NULL;
285 } else {
286 /* special case for restore metadump */
287 list_for_each_entry(device, &info->fs_devices->devices, dev_list) {
288 if (device->devid == 1)
289 break;
290 }
291
292 eb->fd = device->fd;
293 eb->dev_bytenr = eb->start;
294 device->total_ios++;
295 }
296
297 if (read_len > bytes_left)
298 read_len = bytes_left;
299
300 ret = read_extent_from_disk(eb, offset, read_len);
301 if (ret)
302 return -EIO;
303 offset += read_len;
304 bytes_left -= read_len;
305 }
306 return 0;
307 }
308
309 struct extent_buffer* read_tree_block_fs_info(
310 struct btrfs_fs_info *fs_info, u64 bytenr, u32 blocksize,
311 u64 parent_transid)
312 {
313 int ret;
314 struct extent_buffer *eb;
315 u64 best_transid = 0;
316 u32 sectorsize = btrfs_super_sectorsize(fs_info->super_copy);
317 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
318 int mirror_num = 0;
319 int good_mirror = 0;
320 int num_copies;
321 int ignore = 0;
322
323 /*
324 * Don't even try to create tree block for unaligned tree block
325 * bytenr.
326 * Such unaligned tree block will free overlapping extent buffer,
327 * causing use-after-free bugs for fuzzed images.
328 */
329 if (bytenr < sectorsize || !IS_ALIGNED(bytenr, sectorsize)) {
330 error("tree block bytenr %llu is not aligned to sectorsize %u",
331 bytenr, sectorsize);
332 return ERR_PTR(-EIO);
333 }
334 if (blocksize < nodesize || !IS_ALIGNED(blocksize, nodesize)) {
335 error("tree block size %u is not aligned to nodesize %u",
336 blocksize, nodesize);
337 return ERR_PTR(-EIO);
338 }
339
340 eb = btrfs_find_create_tree_block(fs_info, bytenr, blocksize);
341 if (!eb)
342 return ERR_PTR(-ENOMEM);
343
344 if (btrfs_buffer_uptodate(eb, parent_transid))
345 return eb;
346
347 while (1) {
348 ret = read_whole_eb(fs_info, eb, mirror_num);
349 if (ret == 0 && csum_tree_block_fs_info(fs_info, eb, 1) == 0 &&
350 check_tree_block(fs_info, eb) == 0 &&
351 verify_parent_transid(eb->tree, eb, parent_transid, ignore)
352 == 0) {
353 if (eb->flags & EXTENT_BAD_TRANSID &&
354 list_empty(&eb->recow)) {
355 list_add_tail(&eb->recow,
356 &fs_info->recow_ebs);
357 eb->refs++;
358 }
359 btrfs_set_buffer_uptodate(eb);
360 return eb;
361 }
362 if (ignore) {
363 if (check_tree_block(fs_info, eb)) {
364 if (!fs_info->suppress_check_block_errors)
365 print_tree_block_error(fs_info, eb,
366 check_tree_block(fs_info, eb));
367 } else {
368 if (!fs_info->suppress_check_block_errors)
369 fprintf(stderr, "Csum didn't match\n");
370 }
371 ret = -EIO;
372 break;
373 }
374 num_copies = btrfs_num_copies(&fs_info->mapping_tree,
375 eb->start, eb->len);
376 if (num_copies == 1) {
377 ignore = 1;
378 continue;
379 }
380 if (btrfs_header_generation(eb) > best_transid && mirror_num) {
381 best_transid = btrfs_header_generation(eb);
382 good_mirror = mirror_num;
383 }
384 mirror_num++;
385 if (mirror_num > num_copies) {
386 mirror_num = good_mirror;
387 ignore = 1;
388 continue;
389 }
390 }
391 free_extent_buffer(eb);
392 return ERR_PTR(ret);
393 }
394
395 int read_extent_data(struct btrfs_root *root, char *data,
396 u64 logical, u64 *len, int mirror)
397 {
398 u64 offset = 0;
399 struct btrfs_multi_bio *multi = NULL;
400 struct btrfs_fs_info *info = root->fs_info;
401 struct btrfs_device *device;
402 int ret = 0;
403 u64 max_len = *len;
404
405 ret = btrfs_map_block(&info->mapping_tree, READ, logical, len,
406 &multi, mirror, NULL);
407 if (ret) {
408 fprintf(stderr, "Couldn't map the block %llu\n",
409 logical + offset);
410 goto err;
411 }
412 device = multi->stripes[0].dev;
413
414 if (device->fd <= 0)
415 goto err;
416 if (*len > max_len)
417 *len = max_len;
418
419 ret = pread64(device->fd, data, *len, multi->stripes[0].physical);
420 if (ret != *len)
421 ret = -EIO;
422 else
423 ret = 0;
424 err:
425 kfree(multi);
426 return ret;
427 }
428
429 int write_and_map_eb(struct btrfs_trans_handle *trans,
430 struct btrfs_root *root,
431 struct extent_buffer *eb)
432 {
433 int ret;
434 int dev_nr;
435 u64 length;
436 u64 *raid_map = NULL;
437 struct btrfs_multi_bio *multi = NULL;
438
439 dev_nr = 0;
440 length = eb->len;
441 ret = btrfs_map_block(&root->fs_info->mapping_tree, WRITE,
442 eb->start, &length, &multi, 0, &raid_map);
443
444 if (raid_map) {
445 ret = write_raid56_with_parity(root->fs_info, eb, multi,
446 length, raid_map);
447 BUG_ON(ret);
448 } else while (dev_nr < multi->num_stripes) {
449 BUG_ON(ret);
450 eb->fd = multi->stripes[dev_nr].dev->fd;
451 eb->dev_bytenr = multi->stripes[dev_nr].physical;
452 multi->stripes[dev_nr].dev->total_ios++;
453 dev_nr++;
454 ret = write_extent_to_disk(eb);
455 BUG_ON(ret);
456 }
457 kfree(raid_map);
458 kfree(multi);
459 return 0;
460 }
461
462 int write_tree_block(struct btrfs_trans_handle *trans,
463 struct btrfs_root *root,
464 struct extent_buffer *eb)
465 {
466 if (check_tree_block(root->fs_info, eb)) {
467 print_tree_block_error(root->fs_info, eb,
468 check_tree_block(root->fs_info, eb));
469 BUG();
470 }
471
472 if (trans && !btrfs_buffer_uptodate(eb, trans->transid))
473 BUG();
474
475 btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
476 csum_tree_block(root, eb, 0);
477
478 return write_and_map_eb(trans, root, eb);
479 }
480
481 void btrfs_setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
482 u32 stripesize, struct btrfs_root *root,
483 struct btrfs_fs_info *fs_info, u64 objectid)
484 {
485 root->node = NULL;
486 root->commit_root = NULL;
487 root->sectorsize = sectorsize;
488 root->nodesize = nodesize;
489 root->leafsize = leafsize;
490 root->stripesize = stripesize;
491 root->ref_cows = 0;
492 root->track_dirty = 0;
493
494 root->fs_info = fs_info;
495 root->objectid = objectid;
496 root->last_trans = 0;
497 root->last_inode_alloc = 0;
498
499 INIT_LIST_HEAD(&root->dirty_list);
500 INIT_LIST_HEAD(&root->orphan_data_extents);
501 memset(&root->root_key, 0, sizeof(root->root_key));
502 memset(&root->root_item, 0, sizeof(root->root_item));
503 root->root_key.objectid = objectid;
504 }
505
506 static int update_cowonly_root(struct btrfs_trans_handle *trans,
507 struct btrfs_root *root)
508 {
509 int ret;
510 u64 old_root_bytenr;
511 struct btrfs_root *tree_root = root->fs_info->tree_root;
512
513 btrfs_write_dirty_block_groups(trans, root);
514 while(1) {
515 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
516 if (old_root_bytenr == root->node->start)
517 break;
518 btrfs_set_root_bytenr(&root->root_item,
519 root->node->start);
520 btrfs_set_root_generation(&root->root_item,
521 trans->transid);
522 root->root_item.level = btrfs_header_level(root->node);
523 ret = btrfs_update_root(trans, tree_root,
524 &root->root_key,
525 &root->root_item);
526 BUG_ON(ret);
527 btrfs_write_dirty_block_groups(trans, root);
528 }
529 return 0;
530 }
531
532 static int commit_tree_roots(struct btrfs_trans_handle *trans,
533 struct btrfs_fs_info *fs_info)
534 {
535 struct btrfs_root *root;
536 struct list_head *next;
537 struct extent_buffer *eb;
538 int ret;
539
540 if (fs_info->readonly)
541 return 0;
542
543 eb = fs_info->tree_root->node;
544 extent_buffer_get(eb);
545 ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
546 free_extent_buffer(eb);
547 if (ret)
548 return ret;
549
550 while(!list_empty(&fs_info->dirty_cowonly_roots)) {
551 next = fs_info->dirty_cowonly_roots.next;
552 list_del_init(next);
553 root = list_entry(next, struct btrfs_root, dirty_list);
554 update_cowonly_root(trans, root);
555 free_extent_buffer(root->commit_root);
556 root->commit_root = NULL;
557 }
558
559 return 0;
560 }
561
562 static int __commit_transaction(struct btrfs_trans_handle *trans,
563 struct btrfs_root *root)
564 {
565 u64 start;
566 u64 end;
567 struct extent_buffer *eb;
568 struct extent_io_tree *tree = &root->fs_info->extent_cache;
569 int ret;
570
571 while(1) {
572 ret = find_first_extent_bit(tree, 0, &start, &end,
573 EXTENT_DIRTY);
574 if (ret)
575 break;
576 while(start <= end) {
577 eb = find_first_extent_buffer(tree, start);
578 BUG_ON(!eb || eb->start != start);
579 ret = write_tree_block(trans, root, eb);
580 BUG_ON(ret);
581 start += eb->len;
582 clear_extent_buffer_dirty(eb);
583 free_extent_buffer(eb);
584 }
585 }
586 return 0;
587 }
588
589 int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
590 struct btrfs_root *root)
591 {
592 u64 transid = trans->transid;
593 int ret = 0;
594 struct btrfs_fs_info *fs_info = root->fs_info;
595
596 if (root->commit_root == root->node)
597 goto commit_tree;
598 if (root == root->fs_info->tree_root)
599 goto commit_tree;
600 if (root == root->fs_info->chunk_root)
601 goto commit_tree;
602
603 free_extent_buffer(root->commit_root);
604 root->commit_root = NULL;
605
606 btrfs_set_root_bytenr(&root->root_item, root->node->start);
607 btrfs_set_root_generation(&root->root_item, trans->transid);
608 root->root_item.level = btrfs_header_level(root->node);
609 ret = btrfs_update_root(trans, root->fs_info->tree_root,
610 &root->root_key, &root->root_item);
611 BUG_ON(ret);
612 commit_tree:
613 ret = commit_tree_roots(trans, fs_info);
614 BUG_ON(ret);
615 ret = __commit_transaction(trans, root);
616 BUG_ON(ret);
617 write_ctree_super(trans, root);
618 btrfs_finish_extent_commit(trans, fs_info->extent_root,
619 &fs_info->pinned_extents);
620 btrfs_free_transaction(root, trans);
621 free_extent_buffer(root->commit_root);
622 root->commit_root = NULL;
623 fs_info->running_transaction = NULL;
624 fs_info->last_trans_committed = transid;
625 return 0;
626 }
627
628 static int find_and_setup_root(struct btrfs_root *tree_root,
629 struct btrfs_fs_info *fs_info,
630 u64 objectid, struct btrfs_root *root)
631 {
632 int ret;
633 u32 blocksize;
634 u64 generation;
635
636 btrfs_setup_root(tree_root->nodesize, tree_root->leafsize,
637 tree_root->sectorsize, tree_root->stripesize,
638 root, fs_info, objectid);
639 ret = btrfs_find_last_root(tree_root, objectid,
640 &root->root_item, &root->root_key);
641 if (ret)
642 return ret;
643
644 blocksize = root->nodesize;
645 generation = btrfs_root_generation(&root->root_item);
646 root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
647 blocksize, generation);
648 if (!extent_buffer_uptodate(root->node))
649 return -EIO;
650
651 return 0;
652 }
653
654 static int find_and_setup_log_root(struct btrfs_root *tree_root,
655 struct btrfs_fs_info *fs_info,
656 struct btrfs_super_block *disk_super)
657 {
658 u32 blocksize;
659 u64 blocknr = btrfs_super_log_root(disk_super);
660 struct btrfs_root *log_root = malloc(sizeof(struct btrfs_root));
661
662 if (!log_root)
663 return -ENOMEM;
664
665 if (blocknr == 0) {
666 free(log_root);
667 return 0;
668 }
669
670 blocksize = tree_root->nodesize;
671
672 btrfs_setup_root(tree_root->nodesize, tree_root->leafsize,
673 tree_root->sectorsize, tree_root->stripesize,
674 log_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
675
676 log_root->node = read_tree_block(tree_root, blocknr,
677 blocksize,
678 btrfs_super_generation(disk_super) + 1);
679
680 fs_info->log_root_tree = log_root;
681
682 if (!extent_buffer_uptodate(log_root->node)) {
683 free_extent_buffer(log_root->node);
684 free(log_root);
685 fs_info->log_root_tree = NULL;
686 return -EIO;
687 }
688
689 return 0;
690 }
691
692 int btrfs_free_fs_root(struct btrfs_root *root)
693 {
694 if (root->node)
695 free_extent_buffer(root->node);
696 if (root->commit_root)
697 free_extent_buffer(root->commit_root);
698 kfree(root);
699 return 0;
700 }
701
702 static void __free_fs_root(struct rb_node *node)
703 {
704 struct btrfs_root *root;
705
706 root = container_of(node, struct btrfs_root, rb_node);
707 btrfs_free_fs_root(root);
708 }
709
710 FREE_RB_BASED_TREE(fs_roots, __free_fs_root);
711
712 struct btrfs_root *btrfs_read_fs_root_no_cache(struct btrfs_fs_info *fs_info,
713 struct btrfs_key *location)
714 {
715 struct btrfs_root *root;
716 struct btrfs_root *tree_root = fs_info->tree_root;
717 struct btrfs_path *path;
718 struct extent_buffer *l;
719 u64 generation;
720 u32 blocksize;
721 int ret = 0;
722
723 root = calloc(1, sizeof(*root));
724 if (!root)
725 return ERR_PTR(-ENOMEM);
726 if (location->offset == (u64)-1) {
727 ret = find_and_setup_root(tree_root, fs_info,
728 location->objectid, root);
729 if (ret) {
730 free(root);
731 return ERR_PTR(ret);
732 }
733 goto insert;
734 }
735
736 btrfs_setup_root(tree_root->nodesize, tree_root->leafsize,
737 tree_root->sectorsize, tree_root->stripesize,
738 root, fs_info, location->objectid);
739
740 path = btrfs_alloc_path();
741 if (!path) {
742 free(root);
743 return ERR_PTR(-ENOMEM);
744 }
745
746 ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
747 if (ret != 0) {
748 if (ret > 0)
749 ret = -ENOENT;
750 goto out;
751 }
752 l = path->nodes[0];
753 read_extent_buffer(l, &root->root_item,
754 btrfs_item_ptr_offset(l, path->slots[0]),
755 sizeof(root->root_item));
756 memcpy(&root->root_key, location, sizeof(*location));
757 ret = 0;
758 out:
759 btrfs_free_path(path);
760 if (ret) {
761 free(root);
762 return ERR_PTR(ret);
763 }
764 generation = btrfs_root_generation(&root->root_item);
765 blocksize = root->nodesize;
766 root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
767 blocksize, generation);
768 if (!extent_buffer_uptodate(root->node)) {
769 free(root);
770 return ERR_PTR(-EIO);
771 }
772 insert:
773 root->ref_cows = 1;
774 return root;
775 }
776
777 static int btrfs_fs_roots_compare_objectids(struct rb_node *node,
778 void *data)
779 {
780 u64 objectid = *((u64 *)data);
781 struct btrfs_root *root;
782
783 root = rb_entry(node, struct btrfs_root, rb_node);
784 if (objectid > root->objectid)
785 return 1;
786 else if (objectid < root->objectid)
787 return -1;
788 else
789 return 0;
790 }
791
792 static int btrfs_fs_roots_compare_roots(struct rb_node *node1,
793 struct rb_node *node2)
794 {
795 struct btrfs_root *root;
796
797 root = rb_entry(node2, struct btrfs_root, rb_node);
798 return btrfs_fs_roots_compare_objectids(node1, (void *)&root->objectid);
799 }
800
801 struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
802 struct btrfs_key *location)
803 {
804 struct btrfs_root *root;
805 struct rb_node *node;
806 int ret;
807 u64 objectid = location->objectid;
808
809 if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
810 return fs_info->tree_root;
811 if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
812 return fs_info->extent_root;
813 if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
814 return fs_info->chunk_root;
815 if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
816 return fs_info->dev_root;
817 if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
818 return fs_info->csum_root;
819 if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
820 return fs_info->quota_root;
821
822 BUG_ON(location->objectid == BTRFS_TREE_RELOC_OBJECTID ||
823 location->offset != (u64)-1);
824
825 node = rb_search(&fs_info->fs_root_tree, (void *)&objectid,
826 btrfs_fs_roots_compare_objectids, NULL);
827 if (node)
828 return container_of(node, struct btrfs_root, rb_node);
829
830 root = btrfs_read_fs_root_no_cache(fs_info, location);
831 if (IS_ERR(root))
832 return root;
833
834 ret = rb_insert(&fs_info->fs_root_tree, &root->rb_node,
835 btrfs_fs_roots_compare_roots);
836 BUG_ON(ret);
837 return root;
838 }
839
840 void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)
841 {
842 free(fs_info->tree_root);
843 free(fs_info->extent_root);
844 free(fs_info->chunk_root);
845 free(fs_info->dev_root);
846 free(fs_info->csum_root);
847 free(fs_info->quota_root);
848 free(fs_info->free_space_root);
849 free(fs_info->super_copy);
850 free(fs_info->log_root_tree);
851 free(fs_info);
852 }
853
854 struct btrfs_fs_info *btrfs_new_fs_info(int writable, u64 sb_bytenr)
855 {
856 struct btrfs_fs_info *fs_info;
857
858 fs_info = calloc(1, sizeof(struct btrfs_fs_info));
859 if (!fs_info)
860 return NULL;
861
862 fs_info->tree_root = calloc(1, sizeof(struct btrfs_root));
863 fs_info->extent_root = calloc(1, sizeof(struct btrfs_root));
864 fs_info->chunk_root = calloc(1, sizeof(struct btrfs_root));
865 fs_info->dev_root = calloc(1, sizeof(struct btrfs_root));
866 fs_info->csum_root = calloc(1, sizeof(struct btrfs_root));
867 fs_info->quota_root = calloc(1, sizeof(struct btrfs_root));
868 fs_info->free_space_root = calloc(1, sizeof(struct btrfs_root));
869 fs_info->super_copy = calloc(1, BTRFS_SUPER_INFO_SIZE);
870
871 if (!fs_info->tree_root || !fs_info->extent_root ||
872 !fs_info->chunk_root || !fs_info->dev_root ||
873 !fs_info->csum_root || !fs_info->quota_root ||
874 !fs_info->free_space_root || !fs_info->super_copy)
875 goto free_all;
876
877 extent_io_tree_init(&fs_info->extent_cache);
878 extent_io_tree_init(&fs_info->free_space_cache);
879 extent_io_tree_init(&fs_info->block_group_cache);
880 extent_io_tree_init(&fs_info->pinned_extents);
881 extent_io_tree_init(&fs_info->pending_del);
882 extent_io_tree_init(&fs_info->extent_ins);
883 fs_info->excluded_extents = NULL;
884
885 fs_info->fs_root_tree = RB_ROOT;
886 cache_tree_init(&fs_info->mapping_tree.cache_tree);
887
888 mutex_init(&fs_info->fs_mutex);
889 INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
890 INIT_LIST_HEAD(&fs_info->space_info);
891 INIT_LIST_HEAD(&fs_info->recow_ebs);
892
893 if (!writable)
894 fs_info->readonly = 1;
895
896 fs_info->super_bytenr = sb_bytenr;
897 fs_info->data_alloc_profile = (u64)-1;
898 fs_info->metadata_alloc_profile = (u64)-1;
899 fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;
900 return fs_info;
901 free_all:
902 btrfs_free_fs_info(fs_info);
903 return NULL;
904 }
905
906 int btrfs_check_fs_compatibility(struct btrfs_super_block *sb,
907 unsigned int flags)
908 {
909 u64 features;
910
911 features = btrfs_super_incompat_flags(sb) &
912 ~BTRFS_FEATURE_INCOMPAT_SUPP;
913 if (features) {
914 printk("couldn't open because of unsupported "
915 "option features (%Lx).\n",
916 (unsigned long long)features);
917 return -ENOTSUP;
918 }
919
920 features = btrfs_super_incompat_flags(sb);
921 if (!(features & BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF)) {
922 features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
923 btrfs_set_super_incompat_flags(sb, features);
924 }
925
926 features = btrfs_super_compat_ro_flags(sb);
927 if (flags & OPEN_CTREE_WRITES) {
928 if (flags & OPEN_CTREE_INVALIDATE_FST) {
929 /* Clear the FREE_SPACE_TREE_VALID bit on disk... */
930 features &= ~BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID;
931 btrfs_set_super_compat_ro_flags(sb, features);
932 /* ... and ignore the free space tree bit. */
933 features &= ~BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE;
934 }
935 if (features & ~BTRFS_FEATURE_COMPAT_RO_SUPP) {
936 printk("couldn't open RDWR because of unsupported "
937 "option features (%Lx).\n",
938 (unsigned long long)features);
939 return -ENOTSUP;
940 }
941
942 }
943 return 0;
944 }
945
946 static int find_best_backup_root(struct btrfs_super_block *super)
947 {
948 struct btrfs_root_backup *backup;
949 u64 orig_gen = btrfs_super_generation(super);
950 u64 gen = 0;
951 int best_index = 0;
952 int i;
953
954 for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
955 backup = super->super_roots + i;
956 if (btrfs_backup_tree_root_gen(backup) != orig_gen &&
957 btrfs_backup_tree_root_gen(backup) > gen) {
958 best_index = i;
959 gen = btrfs_backup_tree_root_gen(backup);
960 }
961 }
962 return best_index;
963 }
964
965 static int setup_root_or_create_block(struct btrfs_fs_info *fs_info,
966 unsigned flags,
967 struct btrfs_root *info_root,
968 u64 objectid, char *str)
969 {
970 struct btrfs_super_block *sb = fs_info->super_copy;
971 struct btrfs_root *root = fs_info->tree_root;
972 u32 nodesize = btrfs_super_nodesize(sb);
973 int ret;
974
975 ret = find_and_setup_root(root, fs_info, objectid, info_root);
976 if (ret) {
977 printk("Couldn't setup %s tree\n", str);
978 if (!(flags & OPEN_CTREE_PARTIAL))
979 return -EIO;
980 /*
981 * Need a blank node here just so we don't screw up in the
982 * million of places that assume a root has a valid ->node
983 */
984 info_root->node =
985 btrfs_find_create_tree_block(fs_info, 0, nodesize);
986 if (!info_root->node)
987 return -ENOMEM;
988 clear_extent_buffer_uptodate(info_root->node);
989 }
990
991 return 0;
992 }
993
994 int btrfs_setup_all_roots(struct btrfs_fs_info *fs_info, u64 root_tree_bytenr,
995 unsigned flags)
996 {
997 struct btrfs_super_block *sb = fs_info->super_copy;
998 struct btrfs_root *root;
999 struct btrfs_key key;
1000 u32 sectorsize;
1001 u32 nodesize;
1002 u32 leafsize;
1003 u32 stripesize;
1004 u64 generation;
1005 u32 blocksize;
1006 int ret;
1007
1008 nodesize = btrfs_super_nodesize(sb);
1009 leafsize = btrfs_super_leafsize(sb);
1010 sectorsize = btrfs_super_sectorsize(sb);
1011 stripesize = btrfs_super_stripesize(sb);
1012
1013 root = fs_info->tree_root;
1014 btrfs_setup_root(nodesize, leafsize, sectorsize, stripesize,
1015 root, fs_info, BTRFS_ROOT_TREE_OBJECTID);
1016 blocksize = root->nodesize;
1017 generation = btrfs_super_generation(sb);
1018
1019 if (!root_tree_bytenr && !(flags & OPEN_CTREE_BACKUP_ROOT)) {
1020 root_tree_bytenr = btrfs_super_root(sb);
1021 } else if (flags & OPEN_CTREE_BACKUP_ROOT) {
1022 struct btrfs_root_backup *backup;
1023 int index = find_best_backup_root(sb);
1024 if (index >= BTRFS_NUM_BACKUP_ROOTS) {
1025 fprintf(stderr, "Invalid backup root number\n");
1026 return -EIO;
1027 }
1028 backup = fs_info->super_copy->super_roots + index;
1029 root_tree_bytenr = btrfs_backup_tree_root(backup);
1030 generation = btrfs_backup_tree_root_gen(backup);
1031 }
1032
1033 root->node = read_tree_block(root, root_tree_bytenr, blocksize,
1034 generation);
1035 if (!extent_buffer_uptodate(root->node)) {
1036 fprintf(stderr, "Couldn't read tree root\n");
1037 return -EIO;
1038 }
1039
1040 ret = setup_root_or_create_block(fs_info, flags, fs_info->extent_root,
1041 BTRFS_EXTENT_TREE_OBJECTID, "extent");
1042 if (ret)
1043 return ret;
1044 fs_info->extent_root->track_dirty = 1;
1045
1046 ret = find_and_setup_root(root, fs_info, BTRFS_DEV_TREE_OBJECTID,
1047 fs_info->dev_root);
1048 if (ret) {
1049 printk("Couldn't setup device tree\n");
1050 return -EIO;
1051 }
1052 fs_info->dev_root->track_dirty = 1;
1053
1054 ret = setup_root_or_create_block(fs_info, flags, fs_info->csum_root,
1055 BTRFS_CSUM_TREE_OBJECTID, "csum");
1056 if (ret)
1057 return ret;
1058 fs_info->csum_root->track_dirty = 1;
1059
1060 ret = find_and_setup_root(root, fs_info, BTRFS_QUOTA_TREE_OBJECTID,
1061 fs_info->quota_root);
1062 if (ret == 0)
1063 fs_info->quota_enabled = 1;
1064
1065 if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
1066 ret = find_and_setup_root(root, fs_info, BTRFS_FREE_SPACE_TREE_OBJECTID,
1067 fs_info->free_space_root);
1068 if (ret) {
1069 printk("Couldn't read free space tree\n");
1070 return -EIO;
1071 }
1072 fs_info->free_space_root->track_dirty = 1;
1073 }
1074
1075 ret = find_and_setup_log_root(root, fs_info, sb);
1076 if (ret) {
1077 printk("Couldn't setup log root tree\n");
1078 if (!(flags & OPEN_CTREE_PARTIAL))
1079 return -EIO;
1080 }
1081
1082 fs_info->generation = generation;
1083 fs_info->last_trans_committed = generation;
1084 if (extent_buffer_uptodate(fs_info->extent_root->node) &&
1085 !(flags & OPEN_CTREE_NO_BLOCK_GROUPS))
1086 btrfs_read_block_groups(fs_info->tree_root);
1087
1088 key.objectid = BTRFS_FS_TREE_OBJECTID;
1089 key.type = BTRFS_ROOT_ITEM_KEY;
1090 key.offset = (u64)-1;
1091 fs_info->fs_root = btrfs_read_fs_root(fs_info, &key);
1092
1093 if (IS_ERR(fs_info->fs_root))
1094 return -EIO;
1095 return 0;
1096 }
1097
1098 void btrfs_release_all_roots(struct btrfs_fs_info *fs_info)
1099 {
1100 if (fs_info->free_space_root)
1101 free_extent_buffer(fs_info->free_space_root->node);
1102 if (fs_info->quota_root)
1103 free_extent_buffer(fs_info->quota_root->node);
1104 if (fs_info->csum_root)
1105 free_extent_buffer(fs_info->csum_root->node);
1106 if (fs_info->dev_root)
1107 free_extent_buffer(fs_info->dev_root->node);
1108 if (fs_info->extent_root)
1109 free_extent_buffer(fs_info->extent_root->node);
1110 if (fs_info->tree_root)
1111 free_extent_buffer(fs_info->tree_root->node);
1112 if (fs_info->log_root_tree)
1113 free_extent_buffer(fs_info->log_root_tree->node);
1114 if (fs_info->chunk_root)
1115 free_extent_buffer(fs_info->chunk_root->node);
1116 }
1117
1118 static void free_map_lookup(struct cache_extent *ce)
1119 {
1120 struct map_lookup *map;
1121
1122 map = container_of(ce, struct map_lookup, ce);
1123 kfree(map);
1124 }
1125
1126 FREE_EXTENT_CACHE_BASED_TREE(mapping_cache, free_map_lookup);
1127
1128 void btrfs_cleanup_all_caches(struct btrfs_fs_info *fs_info)
1129 {
1130 while (!list_empty(&fs_info->recow_ebs)) {
1131 struct extent_buffer *eb;
1132 eb = list_first_entry(&fs_info->recow_ebs,
1133 struct extent_buffer, recow);
1134 list_del_init(&eb->recow);
1135 free_extent_buffer(eb);
1136 }
1137 free_mapping_cache_tree(&fs_info->mapping_tree.cache_tree);
1138 extent_io_tree_cleanup(&fs_info->extent_cache);
1139 extent_io_tree_cleanup(&fs_info->free_space_cache);
1140 extent_io_tree_cleanup(&fs_info->block_group_cache);
1141 extent_io_tree_cleanup(&fs_info->pinned_extents);
1142 extent_io_tree_cleanup(&fs_info->pending_del);
1143 extent_io_tree_cleanup(&fs_info->extent_ins);
1144 }
1145
1146 int btrfs_scan_fs_devices(int fd, const char *path,
1147 struct btrfs_fs_devices **fs_devices,
1148 u64 sb_bytenr, unsigned sbflags,
1149 int skip_devices)
1150 {
1151 u64 total_devs;
1152 u64 dev_size;
1153 off_t seek_ret;
1154 int ret;
1155 if (!sb_bytenr)
1156 sb_bytenr = BTRFS_SUPER_INFO_OFFSET;
1157
1158 seek_ret = lseek(fd, 0, SEEK_END);
1159 if (seek_ret < 0)
1160 return -errno;
1161
1162 dev_size = seek_ret;
1163 lseek(fd, 0, SEEK_SET);
1164 if (sb_bytenr > dev_size) {
1165 error("superblock bytenr %llu is larger than device size %llu",
1166 (unsigned long long)sb_bytenr,
1167 (unsigned long long)dev_size);
1168 return -EINVAL;
1169 }
1170
1171 ret = btrfs_scan_one_device(fd, path, fs_devices,
1172 &total_devs, sb_bytenr, sbflags);
1173 if (ret) {
1174 fprintf(stderr, "No valid Btrfs found on %s\n", path);
1175 return ret;
1176 }
1177
1178 if (!skip_devices && total_devs != 1) {
1179 ret = btrfs_scan_devices();
1180 if (ret)
1181 return ret;
1182 }
1183 return 0;
1184 }
1185
1186 int btrfs_setup_chunk_tree_and_device_map(struct btrfs_fs_info *fs_info,
1187 u64 chunk_root_bytenr)
1188 {
1189 struct btrfs_super_block *sb = fs_info->super_copy;
1190 u32 sectorsize;
1191 u32 nodesize;
1192 u32 leafsize;
1193 u32 blocksize;
1194 u32 stripesize;
1195 u64 generation;
1196 int ret;
1197
1198 nodesize = btrfs_super_nodesize(sb);
1199 leafsize = btrfs_super_leafsize(sb);
1200 sectorsize = btrfs_super_sectorsize(sb);
1201 stripesize = btrfs_super_stripesize(sb);
1202
1203 btrfs_setup_root(nodesize, leafsize, sectorsize, stripesize,
1204 fs_info->chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
1205
1206 ret = btrfs_read_sys_array(fs_info->chunk_root);
1207 if (ret)
1208 return ret;
1209
1210 blocksize = fs_info->chunk_root->nodesize;
1211 generation = btrfs_super_chunk_root_generation(sb);
1212
1213 if (chunk_root_bytenr && !IS_ALIGNED(chunk_root_bytenr,
1214 btrfs_super_sectorsize(sb))) {
1215 warning("chunk_root_bytenr %llu is unaligned to %u, ignore it",
1216 chunk_root_bytenr, btrfs_super_sectorsize(sb));
1217 chunk_root_bytenr = 0;
1218 }
1219
1220 if (!chunk_root_bytenr)
1221 chunk_root_bytenr = btrfs_super_chunk_root(sb);
1222 else
1223 generation = 0;
1224
1225 fs_info->chunk_root->node = read_tree_block(fs_info->chunk_root,
1226 chunk_root_bytenr,
1227 blocksize, generation);
1228 if (!extent_buffer_uptodate(fs_info->chunk_root->node)) {
1229 if (fs_info->ignore_chunk_tree_error) {
1230 warning("cannot read chunk root, continue anyway");
1231 fs_info->chunk_root = NULL;
1232 return 0;
1233 } else {
1234 error("cannot read chunk root");
1235 return -EIO;
1236 }
1237 }
1238
1239 if (!(btrfs_super_flags(sb) & BTRFS_SUPER_FLAG_METADUMP)) {
1240 ret = btrfs_read_chunk_tree(fs_info->chunk_root);
1241 if (ret) {
1242 fprintf(stderr, "Couldn't read chunk tree\n");
1243 return ret;
1244 }
1245 }
1246 return 0;
1247 }
1248
1249 static struct btrfs_fs_info *__open_ctree_fd(int fp, const char *path,
1250 u64 sb_bytenr,
1251 u64 root_tree_bytenr,
1252 u64 chunk_root_bytenr,
1253 unsigned flags)
1254 {
1255 struct btrfs_fs_info *fs_info;
1256 struct btrfs_super_block *disk_super;
1257 struct btrfs_fs_devices *fs_devices = NULL;
1258 struct extent_buffer *eb;
1259 int ret;
1260 int oflags;
1261 unsigned sbflags = SBREAD_DEFAULT;
1262
1263 if (sb_bytenr == 0)
1264 sb_bytenr = BTRFS_SUPER_INFO_OFFSET;
1265
1266 /* try to drop all the caches */
1267 if (posix_fadvise(fp, 0, 0, POSIX_FADV_DONTNEED))
1268 fprintf(stderr, "Warning, could not drop caches\n");
1269
1270 fs_info = btrfs_new_fs_info(flags & OPEN_CTREE_WRITES, sb_bytenr);
1271 if (!fs_info) {
1272 fprintf(stderr, "Failed to allocate memory for fs_info\n");
1273 return NULL;
1274 }
1275 if (flags & OPEN_CTREE_RESTORE)
1276 fs_info->on_restoring = 1;
1277 if (flags & OPEN_CTREE_SUPPRESS_CHECK_BLOCK_ERRORS)
1278 fs_info->suppress_check_block_errors = 1;
1279 if (flags & OPEN_CTREE_IGNORE_FSID_MISMATCH)
1280 fs_info->ignore_fsid_mismatch = 1;
1281 if (flags & OPEN_CTREE_IGNORE_CHUNK_TREE_ERROR)
1282 fs_info->ignore_chunk_tree_error = 1;
1283
1284 if ((flags & OPEN_CTREE_RECOVER_SUPER)
1285 && (flags & OPEN_CTREE_FS_PARTIAL)) {
1286 fprintf(stderr,
1287 "cannot open a partially created filesystem for recovery");
1288 goto out;
1289 }
1290
1291 if (flags & OPEN_CTREE_FS_PARTIAL)
1292 sbflags = SBREAD_PARTIAL;
1293
1294 ret = btrfs_scan_fs_devices(fp, path, &fs_devices, sb_bytenr, sbflags,
1295 (flags & OPEN_CTREE_NO_DEVICES));
1296 if (ret)
1297 goto out;
1298
1299 fs_info->fs_devices = fs_devices;
1300 if (flags & OPEN_CTREE_WRITES)
1301 oflags = O_RDWR;
1302 else
1303 oflags = O_RDONLY;
1304
1305 if (flags & OPEN_CTREE_EXCLUSIVE)
1306 oflags |= O_EXCL;
1307
1308 ret = btrfs_open_devices(fs_devices, oflags);
1309 if (ret)
1310 goto out;
1311
1312 disk_super = fs_info->super_copy;
1313 if (flags & OPEN_CTREE_RECOVER_SUPER)
1314 ret = btrfs_read_dev_super(fs_devices->latest_bdev, disk_super,
1315 sb_bytenr, SBREAD_RECOVER);
1316 else
1317 ret = btrfs_read_dev_super(fp, disk_super, sb_bytenr,
1318 sbflags);
1319 if (ret) {
1320 printk("No valid btrfs found\n");
1321 goto out_devices;
1322 }
1323
1324 if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_CHANGING_FSID &&
1325 !fs_info->ignore_fsid_mismatch) {
1326 fprintf(stderr, "ERROR: Filesystem UUID change in progress\n");
1327 goto out_devices;
1328 }
1329
1330 memcpy(fs_info->fsid, &disk_super->fsid, BTRFS_FSID_SIZE);
1331
1332 ret = btrfs_check_fs_compatibility(fs_info->super_copy, flags);
1333 if (ret)
1334 goto out_devices;
1335
1336 ret = btrfs_setup_chunk_tree_and_device_map(fs_info, chunk_root_bytenr);
1337 if (ret)
1338 goto out_chunk;
1339
1340 /* Chunk tree root is unable to read, return directly */
1341 if (!fs_info->chunk_root)
1342 return fs_info;
1343
1344 eb = fs_info->chunk_root->node;
1345 read_extent_buffer(eb, fs_info->chunk_tree_uuid,
1346 btrfs_header_chunk_tree_uuid(eb),
1347 BTRFS_UUID_SIZE);
1348
1349 ret = btrfs_setup_all_roots(fs_info, root_tree_bytenr, flags);
1350 if (ret && !(flags & __OPEN_CTREE_RETURN_CHUNK_ROOT) &&
1351 !fs_info->ignore_chunk_tree_error)
1352 goto out_chunk;
1353
1354 return fs_info;
1355
1356 out_chunk:
1357 btrfs_release_all_roots(fs_info);
1358 btrfs_cleanup_all_caches(fs_info);
1359 out_devices:
1360 btrfs_close_devices(fs_devices);
1361 out:
1362 btrfs_free_fs_info(fs_info);
1363 return NULL;
1364 }
1365
1366 struct btrfs_fs_info *open_ctree_fs_info(const char *filename,
1367 u64 sb_bytenr, u64 root_tree_bytenr,
1368 u64 chunk_root_bytenr,
1369 unsigned flags)
1370 {
1371 int fp;
1372 int ret;
1373 struct btrfs_fs_info *info;
1374 int oflags = O_RDWR;
1375 struct stat st;
1376
1377 ret = stat(filename, &st);
1378 if (ret < 0) {
1379 error("cannot stat '%s': %s", filename, strerror(errno));
1380 return NULL;
1381 }
1382 if (!(((st.st_mode & S_IFMT) == S_IFREG) || ((st.st_mode & S_IFMT) == S_IFBLK))) {
1383 error("not a regular file or block device: %s", filename);
1384 return NULL;
1385 }
1386
1387 if (!(flags & OPEN_CTREE_WRITES))
1388 oflags = O_RDONLY;
1389
1390 fp = open(filename, oflags);
1391 if (fp < 0) {
1392 error("cannot open '%s': %s", filename, strerror(errno));
1393 return NULL;
1394 }
1395 info = __open_ctree_fd(fp, filename, sb_bytenr, root_tree_bytenr,
1396 chunk_root_bytenr, flags);
1397 close(fp);
1398 return info;
1399 }
1400
1401 struct btrfs_root *open_ctree(const char *filename, u64 sb_bytenr,
1402 unsigned flags)
1403 {
1404 struct btrfs_fs_info *info;
1405
1406 /* This flags may not return fs_info with any valid root */
1407 BUG_ON(flags & OPEN_CTREE_IGNORE_CHUNK_TREE_ERROR);
1408 info = open_ctree_fs_info(filename, sb_bytenr, 0, 0, flags);
1409 if (!info)
1410 return NULL;
1411 if (flags & __OPEN_CTREE_RETURN_CHUNK_ROOT)
1412 return info->chunk_root;
1413 return info->fs_root;
1414 }
1415
1416 struct btrfs_root *open_ctree_fd(int fp, const char *path, u64 sb_bytenr,
1417 unsigned flags)
1418 {
1419 struct btrfs_fs_info *info;
1420
1421 /* This flags may not return fs_info with any valid root */
1422 if (flags & OPEN_CTREE_IGNORE_CHUNK_TREE_ERROR) {
1423 error("invalid open_ctree flags: 0x%llx",
1424 (unsigned long long)flags);
1425 return NULL;
1426 }
1427 info = __open_ctree_fd(fp, path, sb_bytenr, 0, 0, flags);
1428 if (!info)
1429 return NULL;
1430 if (flags & __OPEN_CTREE_RETURN_CHUNK_ROOT)
1431 return info->chunk_root;
1432 return info->fs_root;
1433 }
1434
1435 /*
1436 * Check if the super is valid:
1437 * - nodesize/sectorsize - minimum, maximum, alignment
1438 * - tree block starts - alignment
1439 * - number of devices - something sane
1440 * - sys array size - maximum
1441 */
1442 static int check_super(struct btrfs_super_block *sb, unsigned sbflags)
1443 {
1444 u8 result[BTRFS_CSUM_SIZE];
1445 u32 crc;
1446 u16 csum_type;
1447 int csum_size;
1448
1449 if (btrfs_super_magic(sb) != BTRFS_MAGIC) {
1450 if (btrfs_super_magic(sb) == BTRFS_MAGIC_PARTIAL) {
1451 if (!(sbflags & SBREAD_PARTIAL)) {
1452 error("superblock magic doesn't match");
1453 return -EIO;
1454 }
1455 }
1456 }
1457
1458 csum_type = btrfs_super_csum_type(sb);
1459 if (csum_type >= ARRAY_SIZE(btrfs_csum_sizes)) {
1460 error("unsupported checksum algorithm %u", csum_type);
1461 return -EIO;
1462 }
1463 csum_size = btrfs_csum_sizes[csum_type];
1464
1465 crc = ~(u32)0;
1466 crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc,
1467 BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
1468 btrfs_csum_final(crc, result);
1469
1470 if (memcmp(result, sb->csum, csum_size)) {
1471 error("superblock checksum mismatch");
1472 return -EIO;
1473 }
1474 if (btrfs_super_root_level(sb) >= BTRFS_MAX_LEVEL) {
1475 error("tree_root level too big: %d >= %d",
1476 btrfs_super_root_level(sb), BTRFS_MAX_LEVEL);
1477 goto error_out;
1478 }
1479 if (btrfs_super_chunk_root_level(sb) >= BTRFS_MAX_LEVEL) {
1480 error("chunk_root level too big: %d >= %d",
1481 btrfs_super_chunk_root_level(sb), BTRFS_MAX_LEVEL);
1482 goto error_out;
1483 }
1484 if (btrfs_super_log_root_level(sb) >= BTRFS_MAX_LEVEL) {
1485 error("log_root level too big: %d >= %d",
1486 btrfs_super_log_root_level(sb), BTRFS_MAX_LEVEL);
1487 goto error_out;
1488 }
1489
1490 if (!IS_ALIGNED(btrfs_super_root(sb), 4096)) {
1491 error("tree_root block unaligned: %llu", btrfs_super_root(sb));
1492 goto error_out;
1493 }
1494 if (!IS_ALIGNED(btrfs_super_chunk_root(sb), 4096)) {
1495 error("chunk_root block unaligned: %llu",
1496 btrfs_super_chunk_root(sb));
1497 goto error_out;
1498 }
1499 if (!IS_ALIGNED(btrfs_super_log_root(sb), 4096)) {
1500 error("log_root block unaligned: %llu",
1501 btrfs_super_log_root(sb));
1502 goto error_out;
1503 }
1504 if (btrfs_super_nodesize(sb) < 4096) {
1505 error("nodesize too small: %u < 4096",
1506 btrfs_super_nodesize(sb));
1507 goto error_out;
1508 }
1509 if (!IS_ALIGNED(btrfs_super_nodesize(sb), 4096)) {
1510 error("nodesize unaligned: %u", btrfs_super_nodesize(sb));
1511 goto error_out;
1512 }
1513 if (btrfs_super_sectorsize(sb) < 4096) {
1514 error("sectorsize too small: %u < 4096",
1515 btrfs_super_sectorsize(sb));
1516 goto error_out;
1517 }
1518 if (!IS_ALIGNED(btrfs_super_sectorsize(sb), 4096)) {
1519 error("sectorsize unaligned: %u", btrfs_super_sectorsize(sb));
1520 goto error_out;
1521 }
1522 if (btrfs_super_total_bytes(sb) == 0) {
1523 error("invalid total_bytes 0");
1524 goto error_out;
1525 }
1526 if (btrfs_super_bytes_used(sb) < 6 * btrfs_super_nodesize(sb)) {
1527 error("invalid bytes_used %llu", btrfs_super_bytes_used(sb));
1528 goto error_out;
1529 }
1530 if ((btrfs_super_stripesize(sb) != 4096)
1531 && (btrfs_super_stripesize(sb) != btrfs_super_sectorsize(sb))) {
1532 error("invalid stripesize %u", btrfs_super_stripesize(sb));
1533 goto error_out;
1534 }
1535
1536 if (memcmp(sb->fsid, sb->dev_item.fsid, BTRFS_UUID_SIZE) != 0) {
1537 char fsid[BTRFS_UUID_UNPARSED_SIZE];
1538 char dev_fsid[BTRFS_UUID_UNPARSED_SIZE];
1539
1540 uuid_unparse(sb->fsid, fsid);
1541 uuid_unparse(sb->dev_item.fsid, dev_fsid);
1542 error("dev_item UUID does not match fsid: %s != %s",
1543 dev_fsid, fsid);
1544 goto error_out;
1545 }
1546
1547 /*
1548 * Hint to catch really bogus numbers, bitflips or so
1549 */
1550 if (btrfs_super_num_devices(sb) > (1UL << 31)) {
1551 warning("suspicious number of devices: %llu",
1552 btrfs_super_num_devices(sb));
1553 }
1554
1555 if (btrfs_super_num_devices(sb) == 0) {
1556 error("number of devices is 0");
1557 goto error_out;
1558 }
1559
1560 /*
1561 * Obvious sys_chunk_array corruptions, it must hold at least one key
1562 * and one chunk
1563 */
1564 if (btrfs_super_sys_array_size(sb) > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) {
1565 error("system chunk array too big %u > %u",
1566 btrfs_super_sys_array_size(sb),
1567 BTRFS_SYSTEM_CHUNK_ARRAY_SIZE);
1568 goto error_out;
1569 }
1570 if (btrfs_super_sys_array_size(sb) < sizeof(struct btrfs_disk_key)
1571 + sizeof(struct btrfs_chunk)) {
1572 error("system chunk array too small %u < %zu",
1573 btrfs_super_sys_array_size(sb),
1574 sizeof(struct btrfs_disk_key) +
1575 sizeof(struct btrfs_chunk));
1576 goto error_out;
1577 }
1578
1579 return 0;
1580
1581 error_out:
1582 error("superblock checksum matches but it has invalid members");
1583 return -EIO;
1584 }
1585
1586 int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr,
1587 unsigned sbflags)
1588 {
1589 u8 fsid[BTRFS_FSID_SIZE];
1590 int fsid_is_initialized = 0;
1591 char tmp[BTRFS_SUPER_INFO_SIZE];
1592 struct btrfs_super_block *buf = (struct btrfs_super_block *)tmp;
1593 int i;
1594 int ret;
1595 int max_super = sbflags & SBREAD_RECOVER ? BTRFS_SUPER_MIRROR_MAX : 1;
1596 u64 transid = 0;
1597 u64 bytenr;
1598
1599 if (sb_bytenr != BTRFS_SUPER_INFO_OFFSET) {
1600 ret = pread64(fd, buf, BTRFS_SUPER_INFO_SIZE, sb_bytenr);
1601 /* real error */
1602 if (ret < 0)
1603 return -errno;
1604
1605 /* Not large enough sb, return -ENOENT instead of normal -EIO */
1606 if (ret < BTRFS_SUPER_INFO_SIZE)
1607 return -ENOENT;
1608
1609 if (btrfs_super_bytenr(buf) != sb_bytenr)
1610 return -EIO;
1611
1612 ret = check_super(buf, sbflags);
1613 if (ret < 0)
1614 return ret;
1615 memcpy(sb, buf, BTRFS_SUPER_INFO_SIZE);
1616 return 0;
1617 }
1618
1619 /*
1620 * we would like to check all the supers, but that would make
1621 * a btrfs mount succeed after a mkfs from a different FS.
1622 * So, we need to add a special mount option to scan for
1623 * later supers, using BTRFS_SUPER_MIRROR_MAX instead
1624 */
1625
1626 for (i = 0; i < max_super; i++) {
1627 bytenr = btrfs_sb_offset(i);
1628 ret = pread64(fd, buf, BTRFS_SUPER_INFO_SIZE, bytenr);
1629 if (ret < BTRFS_SUPER_INFO_SIZE)
1630 break;
1631
1632 if (btrfs_super_bytenr(buf) != bytenr )
1633 continue;
1634 /* if magic is NULL, the device was removed */
1635 if (btrfs_super_magic(buf) == 0 && i == 0)
1636 break;
1637 if (check_super(buf, sbflags))
1638 continue;
1639
1640 if (!fsid_is_initialized) {
1641 memcpy(fsid, buf->fsid, sizeof(fsid));
1642 fsid_is_initialized = 1;
1643 } else if (memcmp(fsid, buf->fsid, sizeof(fsid))) {
1644 /*
1645 * the superblocks (the original one and
1646 * its backups) contain data of different
1647 * filesystems -> the super cannot be trusted
1648 */
1649 continue;
1650 }
1651
1652 if (btrfs_super_generation(buf) > transid) {
1653 memcpy(sb, buf, BTRFS_SUPER_INFO_SIZE);
1654 transid = btrfs_super_generation(buf);
1655 }
1656 }
1657
1658 return transid > 0 ? 0 : -1;
1659 }
1660
1661 static int write_dev_supers(struct btrfs_root *root,
1662 struct btrfs_super_block *sb,
1663 struct btrfs_device *device)
1664 {
1665 u64 bytenr;
1666 u32 crc;
1667 int i, ret;
1668
1669 if (root->fs_info->super_bytenr != BTRFS_SUPER_INFO_OFFSET) {
1670 btrfs_set_super_bytenr(sb, root->fs_info->super_bytenr);
1671 crc = ~(u32)0;
1672 crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc,
1673 BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
1674 btrfs_csum_final(crc, &sb->csum[0]);
1675
1676 /*
1677 * super_copy is BTRFS_SUPER_INFO_SIZE bytes and is
1678 * zero filled, we can use it directly
1679 */
1680 ret = pwrite64(device->fd, root->fs_info->super_copy,
1681 BTRFS_SUPER_INFO_SIZE,
1682 root->fs_info->super_bytenr);
1683 if (ret != BTRFS_SUPER_INFO_SIZE)
1684 goto write_err;
1685 return 0;
1686 }
1687
1688 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
1689 bytenr = btrfs_sb_offset(i);
1690 if (bytenr + BTRFS_SUPER_INFO_SIZE > device->total_bytes)
1691 break;
1692
1693 btrfs_set_super_bytenr(sb, bytenr);
1694
1695 crc = ~(u32)0;
1696 crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc,
1697 BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
1698 btrfs_csum_final(crc, &sb->csum[0]);
1699
1700 /*
1701 * super_copy is BTRFS_SUPER_INFO_SIZE bytes and is
1702 * zero filled, we can use it directly
1703 */
1704 ret = pwrite64(device->fd, root->fs_info->super_copy,
1705 BTRFS_SUPER_INFO_SIZE, bytenr);
1706 if (ret != BTRFS_SUPER_INFO_SIZE)
1707 goto write_err;
1708 }
1709
1710 return 0;
1711
1712 write_err:
1713 if (ret > 0)
1714 fprintf(stderr, "WARNING: failed to write all sb data\n");
1715 else
1716 fprintf(stderr, "WARNING: failed to write sb: %s\n",
1717 strerror(errno));
1718 return ret;
1719 }
1720
1721 int write_all_supers(struct btrfs_root *root)
1722 {
1723 struct list_head *cur;
1724 struct list_head *head = &root->fs_info->fs_devices->devices;
1725 struct btrfs_device *dev;
1726 struct btrfs_super_block *sb;
1727 struct btrfs_dev_item *dev_item;
1728 int ret;
1729 u64 flags;
1730
1731 sb = root->fs_info->super_copy;
1732 dev_item = &sb->dev_item;
1733 list_for_each(cur, head) {
1734 dev = list_entry(cur, struct btrfs_device, dev_list);
1735 if (!dev->writeable)
1736 continue;
1737
1738 btrfs_set_stack_device_generation(dev_item, 0);
1739 btrfs_set_stack_device_type(dev_item, dev->type);
1740 btrfs_set_stack_device_id(dev_item, dev->devid);
1741 btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);
1742 btrfs_set_stack_device_bytes_used(dev_item, dev->bytes_used);
1743 btrfs_set_stack_device_io_align(dev_item, dev->io_align);
1744 btrfs_set_stack_device_io_width(dev_item, dev->io_width);
1745 btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
1746 memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
1747 memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
1748
1749 flags = btrfs_super_flags(sb);
1750 btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
1751
1752 ret = write_dev_supers(root, sb, dev);
1753 BUG_ON(ret);
1754 }
1755 return 0;
1756 }
1757
1758 int write_ctree_super(struct btrfs_trans_handle *trans,
1759 struct btrfs_root *root)
1760 {
1761 int ret;
1762 struct btrfs_root *tree_root = root->fs_info->tree_root;
1763 struct btrfs_root *chunk_root = root->fs_info->chunk_root;
1764
1765 if (root->fs_info->readonly)
1766 return 0;
1767
1768 btrfs_set_super_generation(root->fs_info->super_copy,
1769 trans->transid);
1770 btrfs_set_super_root(root->fs_info->super_copy,
1771 tree_root->node->start);
1772 btrfs_set_super_root_level(root->fs_info->super_copy,
1773 btrfs_header_level(tree_root->node));
1774 btrfs_set_super_chunk_root(root->fs_info->super_copy,
1775 chunk_root->node->start);
1776 btrfs_set_super_chunk_root_level(root->fs_info->super_copy,
1777 btrfs_header_level(chunk_root->node));
1778 btrfs_set_super_chunk_root_generation(root->fs_info->super_copy,
1779 btrfs_header_generation(chunk_root->node));
1780
1781 ret = write_all_supers(root);
1782 if (ret)
1783 fprintf(stderr, "failed to write new super block err %d\n", ret);
1784 return ret;
1785 }
1786
1787 int close_ctree_fs_info(struct btrfs_fs_info *fs_info)
1788 {
1789 int ret;
1790 struct btrfs_trans_handle *trans;
1791 struct btrfs_root *root = fs_info->tree_root;
1792
1793 if (fs_info->last_trans_committed !=
1794 fs_info->generation) {
1795 BUG_ON(!root);
1796 trans = btrfs_start_transaction(root, 1);
1797 btrfs_commit_transaction(trans, root);
1798 trans = btrfs_start_transaction(root, 1);
1799 ret = commit_tree_roots(trans, fs_info);
1800 BUG_ON(ret);
1801 ret = __commit_transaction(trans, root);
1802 BUG_ON(ret);
1803 write_ctree_super(trans, root);
1804 btrfs_free_transaction(root, trans);
1805 }
1806
1807 if (fs_info->finalize_on_close) {
1808 btrfs_set_super_magic(fs_info->super_copy, BTRFS_MAGIC);
1809 root->fs_info->finalize_on_close = 0;
1810 ret = write_all_supers(root);
1811 if (ret)
1812 fprintf(stderr,
1813 "failed to write new super block err %d\n", ret);
1814 }
1815 btrfs_free_block_groups(fs_info);
1816
1817 free_fs_roots_tree(&fs_info->fs_root_tree);
1818
1819 btrfs_release_all_roots(fs_info);
1820 btrfs_close_devices(fs_info->fs_devices);
1821 btrfs_cleanup_all_caches(fs_info);
1822 btrfs_free_fs_info(fs_info);
1823 return 0;
1824 }
1825
1826 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1827 struct extent_buffer *eb)
1828 {
1829 return clear_extent_buffer_dirty(eb);
1830 }
1831
1832 int wait_on_tree_block_writeback(struct btrfs_root *root,
1833 struct extent_buffer *eb)
1834 {
1835 return 0;
1836 }
1837
1838 void btrfs_mark_buffer_dirty(struct extent_buffer *eb)
1839 {
1840 set_extent_buffer_dirty(eb);
1841 }
1842
1843 int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid)
1844 {
1845 int ret;
1846
1847 ret = extent_buffer_uptodate(buf);
1848 if (!ret)
1849 return ret;
1850
1851 ret = verify_parent_transid(buf->tree, buf, parent_transid, 1);
1852 return !ret;
1853 }
1854
1855 int btrfs_set_buffer_uptodate(struct extent_buffer *eb)
1856 {
1857 return set_extent_buffer_uptodate(eb);
1858 }
(deprecated) Btrfs progs developments and patch integration