2 * Copyright (C) 2011 Red Hat. All rights reserved.
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.
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.
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.
19 #define _XOPEN_SOURCE 500
27 #include "kerncompat.h"
30 #include "print-tree.h"
31 #include "transaction.h"
38 static u16 csum_size = 0;
39 static u64 search_objectid = BTRFS_ROOT_TREE_OBJECTID;
43 fprintf(stderr, "Usage: find-roots [-o search_objectid] <device>\n");
46 int csum_block(void *buf, u32 len)
52 result = malloc(csum_size * sizeof(char));
54 fprintf(stderr, "No memory\n");
58 len -= BTRFS_CSUM_SIZE;
59 crc = crc32c(crc, buf + BTRFS_CSUM_SIZE, len);
60 btrfs_csum_final(crc, result);
62 if (memcmp(buf, result, csum_size))
68 static int close_all_devices(struct btrfs_fs_info *fs_info)
70 struct list_head *list;
71 struct list_head *next;
72 struct btrfs_device *device;
76 list = &fs_info->fs_devices->devices;
77 list_for_each(next, list) {
78 device = list_entry(next, struct btrfs_device, dev_list);
79 if (device->fd != -1) {
87 static struct btrfs_root *open_ctree_broken(int fd, const char *device)
95 struct btrfs_root *tree_root = malloc(sizeof(struct btrfs_root));
96 struct btrfs_root *extent_root = malloc(sizeof(struct btrfs_root));
97 struct btrfs_root *chunk_root = malloc(sizeof(struct btrfs_root));
98 struct btrfs_root *dev_root = malloc(sizeof(struct btrfs_root));
99 struct btrfs_root *csum_root = malloc(sizeof(struct btrfs_root));
100 struct btrfs_fs_info *fs_info = malloc(sizeof(*fs_info));
102 struct btrfs_super_block *disk_super;
103 struct btrfs_fs_devices *fs_devices = NULL;
107 ret = btrfs_scan_one_device(fd, device, &fs_devices,
108 &total_devs, BTRFS_SUPER_INFO_OFFSET);
111 fprintf(stderr, "No valid Btrfs found on %s\n", device);
115 if (total_devs != 1) {
116 ret = btrfs_scan_for_fsid(fs_devices, total_devs, 1);
121 memset(fs_info, 0, sizeof(*fs_info));
122 fs_info->super_copy = calloc(1, BTRFS_SUPER_INFO_SIZE);
123 fs_info->tree_root = tree_root;
124 fs_info->extent_root = extent_root;
125 fs_info->chunk_root = chunk_root;
126 fs_info->dev_root = dev_root;
127 fs_info->csum_root = csum_root;
129 fs_info->readonly = 1;
131 extent_io_tree_init(&fs_info->extent_cache);
132 extent_io_tree_init(&fs_info->free_space_cache);
133 extent_io_tree_init(&fs_info->block_group_cache);
134 extent_io_tree_init(&fs_info->pinned_extents);
135 extent_io_tree_init(&fs_info->pending_del);
136 extent_io_tree_init(&fs_info->extent_ins);
137 cache_tree_init(&fs_info->fs_root_cache);
139 cache_tree_init(&fs_info->mapping_tree.cache_tree);
141 mutex_init(&fs_info->fs_mutex);
142 fs_info->fs_devices = fs_devices;
143 INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
144 INIT_LIST_HEAD(&fs_info->space_info);
146 __setup_root(4096, 4096, 4096, 4096, tree_root,
147 fs_info, BTRFS_ROOT_TREE_OBJECTID);
149 ret = btrfs_open_devices(fs_devices, O_RDONLY);
153 fs_info->super_bytenr = BTRFS_SUPER_INFO_OFFSET;
154 disk_super = fs_info->super_copy;
155 ret = btrfs_read_dev_super(fs_devices->latest_bdev,
156 disk_super, BTRFS_SUPER_INFO_OFFSET);
158 printk("No valid btrfs found\n");
162 memcpy(fs_info->fsid, &disk_super->fsid, BTRFS_FSID_SIZE);
165 features = btrfs_super_incompat_flags(disk_super) &
166 ~BTRFS_FEATURE_INCOMPAT_SUPP;
168 printk("couldn't open because of unsupported "
169 "option features (%Lx).\n", features);
173 features = btrfs_super_incompat_flags(disk_super);
174 if (!(features & BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF)) {
175 features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
176 btrfs_set_super_incompat_flags(disk_super, features);
179 nodesize = btrfs_super_nodesize(disk_super);
180 leafsize = btrfs_super_leafsize(disk_super);
181 sectorsize = btrfs_super_sectorsize(disk_super);
182 stripesize = btrfs_super_stripesize(disk_super);
183 tree_root->nodesize = nodesize;
184 tree_root->leafsize = leafsize;
185 tree_root->sectorsize = sectorsize;
186 tree_root->stripesize = stripesize;
188 ret = btrfs_read_sys_array(tree_root);
191 blocksize = btrfs_level_size(tree_root,
192 btrfs_super_chunk_root_level(disk_super));
193 generation = btrfs_super_chunk_root_generation(disk_super);
195 __setup_root(nodesize, leafsize, sectorsize, stripesize,
196 chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
198 chunk_root->node = read_tree_block(chunk_root,
199 btrfs_super_chunk_root(disk_super),
200 blocksize, generation);
201 if (!chunk_root->node) {
202 printk("Couldn't read chunk root\n");
206 read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
207 (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
210 if (!(btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_METADUMP)) {
211 ret = btrfs_read_chunk_tree(chunk_root);
216 return fs_info->chunk_root;
218 free_extent_buffer(fs_info->chunk_root->node);
220 close_all_devices(fs_info);
222 extent_io_tree_cleanup(&fs_info->extent_cache);
223 extent_io_tree_cleanup(&fs_info->free_space_cache);
224 extent_io_tree_cleanup(&fs_info->block_group_cache);
225 extent_io_tree_cleanup(&fs_info->pinned_extents);
226 extent_io_tree_cleanup(&fs_info->pending_del);
227 extent_io_tree_cleanup(&fs_info->extent_ins);
238 static int search_iobuf(struct btrfs_root *root, void *iobuf,
239 size_t iobuf_size, off_t offset)
241 u64 gen = btrfs_super_generation(root->fs_info->super_copy);
242 u64 objectid = search_objectid;
243 u32 size = btrfs_super_nodesize(root->fs_info->super_copy);
244 u8 level = root->fs_info->super_copy->root_level;
245 size_t block_off = 0;
247 while (block_off < iobuf_size) {
248 void *block = iobuf + block_off;
249 struct btrfs_header *header = block;
250 u64 h_byte, h_level, h_gen, h_owner;
252 // printf("searching %Lu\n", offset + block_off);
253 h_byte = le64_to_cpu(header->bytenr);
254 h_owner = le64_to_cpu(header->owner);
255 h_level = header->level;
256 h_gen = le64_to_cpu(header->generation);
258 if (h_owner != objectid)
260 if (h_byte != (offset + block_off))
262 if (h_level != level)
264 if (csum_block(block, size)) {
265 fprintf(stderr, "Well block %Lu seems good, "
266 "but the csum doesn't match\n",
271 fprintf(stderr, "Well block %Lu seems great, "
272 "but generation doesn't match, "
273 "have=%Lu, want=%Lu\n", h_byte, h_gen,
277 printf("Found tree root at %Lu\n", h_byte);
286 static int read_physical(struct btrfs_root *root, int fd, u64 offset,
289 char *iobuf = malloc(len);
291 size_t total_read = 0;
295 fprintf(stderr, "No memory\n");
299 while (total_read < len) {
300 done = pread64(fd, iobuf + total_read, len - total_read,
301 bytenr + total_read);
303 fprintf(stderr, "Failed to read: %s\n",
311 ret = search_iobuf(root, iobuf, total_read, offset);
317 static int find_root(struct btrfs_root *root)
319 struct btrfs_multi_bio *multi = NULL;
320 struct btrfs_device *device;
321 u64 metadata_offset = 0, metadata_size = 0;
328 printf("Super think's the tree root is at %Lu, chunk root %Lu\n",
329 btrfs_super_root(root->fs_info->super_copy),
330 btrfs_super_chunk_root(root->fs_info->super_copy));
332 err = btrfs_next_metadata(&root->fs_info->mapping_tree,
333 &metadata_offset, &metadata_size);
337 offset = metadata_offset;
339 u64 map_length = 4096;
343 btrfs_super_total_bytes(root->fs_info->super_copy)) {
344 printf("Went past the fs size, exiting");
347 if (offset >= (metadata_offset + metadata_size)) {
348 err = btrfs_next_metadata(&root->fs_info->mapping_tree,
352 printf("No more metdata to scan, exiting\n");
355 offset = metadata_offset;
357 err = __btrfs_map_block(&root->fs_info->mapping_tree, READ,
358 offset, &map_length, &type,
361 offset += map_length;
365 if (!(type & BTRFS_BLOCK_GROUP_METADATA)) {
366 offset += map_length;
371 device = multi->stripes[0].dev;
373 bytenr = multi->stripes[0].physical;
376 err = read_physical(root, fd, offset, bytenr, map_length);
380 } else if (err < 0) {
384 offset += map_length;
389 int main(int argc, char **argv)
391 struct btrfs_root *root;
396 while ((opt = getopt(argc, argv, "o:")) != -1) {
400 search_objectid = (u64)strtoll(optarg, NULL,
403 fprintf(stderr, "Error parsing "
414 if (optind >= argc) {
419 dev_fd = open(argv[optind], O_RDONLY);
421 fprintf(stderr, "Failed to open device %s\n", argv[optind]);
425 root = open_ctree_broken(dev_fd, argv[optind]);
429 fprintf(stderr, "Open ctree failed\n");
433 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
434 ret = find_root(root);