2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public
4 * License v2 as published by the Free Software Foundation.
6 * This program is distributed in the hope that it will be useful,
7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
9 * General Public License for more details.
11 * You should have received a copy of the GNU General Public
12 * License along with this program; if not, write to the
13 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
14 * Boston, MA 021110-1307, USA.
21 #include <sys/ioctl.h>
26 #include "kerncompat.h"
30 #include "send-utils.h"
33 #include "btrfs-list.h"
34 #include "cmds-inspect-dump-tree.h"
35 #include "cmds-inspect-dump-super.h"
36 #include "cmds-inspect-tree-stats.h"
38 static const char * const inspect_cmd_group_usage[] = {
39 "btrfs inspect-internal <command> <args>",
43 static int __ino_to_path_fd(u64 inum, int fd, int verbose, const char *prepend)
47 struct btrfs_ioctl_ino_path_args ipa;
48 struct btrfs_data_container fspath[PATH_MAX];
50 memset(fspath, 0, sizeof(*fspath));
53 ipa.fspath = ptr_to_u64(fspath);
55 ret = ioctl(fd, BTRFS_IOC_INO_PATHS, &ipa);
57 error("ino paths ioctl: %s", strerror(errno));
62 printf("ioctl ret=%d, bytes_left=%lu, bytes_missing=%lu, "
63 "cnt=%d, missed=%d\n", ret,
64 (unsigned long)fspath->bytes_left,
65 (unsigned long)fspath->bytes_missing,
66 fspath->elem_cnt, fspath->elem_missed);
68 for (i = 0; i < fspath->elem_cnt; ++i) {
71 ptr = (u64)(unsigned long)fspath->val;
72 ptr += fspath->val[i];
73 str = (char *)(unsigned long)ptr;
75 printf("%s/%s\n", prepend, str);
84 static const char * const cmd_inspect_inode_resolve_usage[] = {
85 "btrfs inspect-internal inode-resolve [-v] <inode> <path>",
86 "Get file system paths for the given inode",
92 static int cmd_inspect_inode_resolve(int argc, char **argv)
97 DIR *dirstream = NULL;
101 int c = getopt(argc, argv, "v");
110 usage(cmd_inspect_inode_resolve_usage);
114 if (check_argc_exact(argc - optind, 2))
115 usage(cmd_inspect_inode_resolve_usage);
117 fd = btrfs_open_dir(argv[optind + 1], &dirstream, 1);
121 ret = __ino_to_path_fd(arg_strtou64(argv[optind]), fd, verbose,
123 close_file_or_dir(fd, dirstream);
128 static const char * const cmd_inspect_logical_resolve_usage[] = {
129 "btrfs inspect-internal logical-resolve [-Pv] [-s bufsize] <logical> <path>",
130 "Get file system paths for the given logical address",
131 "-P skip the path resolving and print the inodes instead",
133 "-s bufsize set inode container's size. This is used to increase inode",
134 " container's size in case it is not enough to read all the ",
135 " resolved results. The max value one can set is 64k",
139 static int cmd_inspect_logical_resolve(int argc, char **argv)
147 struct btrfs_ioctl_logical_ino_args loi;
148 struct btrfs_data_container *inodes;
150 char full_path[4096];
152 DIR *dirstream = NULL;
156 int c = getopt(argc, argv, "Pvs:");
168 size = arg_strtou64(optarg);
171 usage(cmd_inspect_logical_resolve_usage);
175 if (check_argc_exact(argc - optind, 2))
176 usage(cmd_inspect_logical_resolve_usage);
178 size = min(size, (u64)64 * 1024);
179 inodes = malloc(size);
183 memset(inodes, 0, sizeof(*inodes));
184 loi.logical = arg_strtou64(argv[optind]);
186 loi.inodes = ptr_to_u64(inodes);
188 fd = btrfs_open_dir(argv[optind + 1], &dirstream, 1);
194 ret = ioctl(fd, BTRFS_IOC_LOGICAL_INO, &loi);
196 error("logical ino ioctl: %s", strerror(errno));
201 printf("ioctl ret=%d, total_size=%llu, bytes_left=%lu, "
202 "bytes_missing=%lu, cnt=%d, missed=%d\n",
204 (unsigned long)inodes->bytes_left,
205 (unsigned long)inodes->bytes_missing,
206 inodes->elem_cnt, inodes->elem_missed);
208 bytes_left = sizeof(full_path);
209 ret = snprintf(full_path, bytes_left, "%s/", argv[optind+1]);
210 path_ptr = full_path + ret;
211 bytes_left -= ret + 1;
212 BUG_ON(bytes_left < 0);
214 for (i = 0; i < inodes->elem_cnt; i += 3) {
215 u64 inum = inodes->val[i];
216 u64 offset = inodes->val[i+1];
217 u64 root = inodes->val[i+2];
223 name = btrfs_list_path_for_root(fd, root);
233 ret = snprintf(path_ptr, bytes_left, "%s",
235 BUG_ON(ret >= bytes_left);
237 path_fd = btrfs_open_dir(full_path, &dirs, 1);
243 __ino_to_path_fd(inum, path_fd, verbose, full_path);
245 close_file_or_dir(path_fd, dirs);
247 printf("inode %llu offset %llu root %llu\n", inum,
253 close_file_or_dir(fd, dirstream);
258 static const char * const cmd_inspect_subvolid_resolve_usage[] = {
259 "btrfs inspect-internal subvolid-resolve <subvolid> <path>",
260 "Get file system paths for the given subvolume ID.",
264 static int cmd_inspect_subvolid_resolve(int argc, char **argv)
270 DIR *dirstream = NULL;
272 clean_args_no_options(argc, argv, cmd_inspect_subvolid_resolve_usage);
274 if (check_argc_exact(argc - optind, 2))
275 usage(cmd_inspect_subvolid_resolve_usage);
277 fd = btrfs_open_dir(argv[optind + 1], &dirstream, 1);
283 subvol_id = arg_strtou64(argv[optind]);
284 ret = btrfs_subvolid_resolve(fd, path, sizeof(path), subvol_id);
287 error("resolving subvolid %llu error %d",
288 (unsigned long long)subvol_id, ret);
292 path[PATH_MAX - 1] = '\0';
293 printf("%s\n", path);
296 close_file_or_dir(fd, dirstream);
300 static const char* const cmd_inspect_rootid_usage[] = {
301 "btrfs inspect-internal rootid <path>",
302 "Get tree ID of the containing subvolume of path.",
306 static int cmd_inspect_rootid(int argc, char **argv)
311 DIR *dirstream = NULL;
313 clean_args_no_options(argc, argv, cmd_inspect_rootid_usage);
315 if (check_argc_exact(argc - optind, 1))
316 usage(cmd_inspect_rootid_usage);
318 fd = btrfs_open_dir(argv[optind], &dirstream, 1);
324 ret = lookup_ino_rootid(fd, &rootid);
326 error("rootid failed with ret=%d", ret);
330 printf("%llu\n", (unsigned long long)rootid);
332 close_file_or_dir(fd, dirstream);
337 static const char* const cmd_inspect_min_dev_size_usage[] = {
338 "btrfs inspect-internal min-dev-size [options] <path>",
339 "Get the minimum size the device can be shrunk to. The",
340 "device id 1 is used by default.",
341 "--id DEVID specify the device id to query",
345 struct dev_extent_elem {
349 struct list_head list;
352 static int add_dev_extent(struct list_head *list,
353 const u64 start, const u64 end,
356 struct dev_extent_elem *e;
358 e = malloc(sizeof(*e));
366 list_add_tail(&e->list, list);
368 list_add(&e->list, list);
373 static void free_dev_extent_list(struct list_head *list)
375 while (!list_empty(list)) {
376 struct dev_extent_elem *e;
378 e = list_first_entry(list, struct dev_extent_elem, list);
384 static int hole_includes_sb_mirror(const u64 start, const u64 end)
389 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
390 u64 bytenr = btrfs_sb_offset(i);
392 if (bytenr >= start && bytenr <= end) {
401 static void adjust_dev_min_size(struct list_head *extents,
402 struct list_head *holes,
406 * If relocation of the block group of a device extent must happen (see
407 * below) scratch space is used for the relocation. So track here the
408 * size of the largest device extent that has to be relocated. We track
409 * only the largest and not the sum of the sizes of all relocated block
410 * groups because after each block group is relocated the running
411 * transaction is committed so that pinned space is released.
413 u64 scratch_space = 0;
416 * List of device extents is sorted by descending order of the extent's
417 * end offset. If some extent goes beyond the computed minimum size,
418 * which initially matches the sum of the lenghts of all extents,
419 * we need to check if the extent can be relocated to an hole in the
420 * device between [0, *min_size[ (which is what the resize ioctl does).
422 while (!list_empty(extents)) {
423 struct dev_extent_elem *e;
424 struct dev_extent_elem *h;
429 e = list_first_entry(extents, struct dev_extent_elem, list);
430 if (e->end <= *min_size)
434 * Our extent goes beyond the computed *min_size. See if we can
435 * find a hole large enough to relocate it to. If not we must stop
436 * and set *min_size to the end of the extent.
438 extent_len = e->end - e->start + 1;
439 list_for_each_entry(h, holes, list) {
440 hole_len = h->end - h->start + 1;
441 if (hole_len >= extent_len) {
448 *min_size = e->end + 1;
453 * If the hole found contains the location for a superblock
454 * mirror, we are pessimistic and require allocating one
455 * more extent of the same size. This is because the block
456 * group could be in the worst case used by a single extent
457 * with a size >= (block_group.length - superblock.size).
459 if (hole_includes_sb_mirror(h->start,
460 h->start + extent_len - 1))
461 *min_size += extent_len;
463 if (hole_len > extent_len) {
464 h->start += extent_len;
473 if (extent_len > scratch_space)
474 scratch_space = extent_len;
478 *min_size += scratch_space;
480 * Chunk allocation requires inserting/updating items in the
481 * chunk tree, so often this can lead to the need of allocating
482 * a new system chunk too, which has a maximum size of 32Mb.
484 *min_size += 32 * 1024 * 1024;
488 static int print_min_dev_size(int fd, u64 devid)
492 * Device allocations starts at 1Mb or at the value passed through the
493 * mount option alloc_start if it's bigger than 1Mb. The alloc_start
494 * option is used for debugging and testing only, and recently the
495 * possibility of deprecating/removing it has been discussed, so we
498 u64 min_size = 1 * 1024 * 1024ull;
499 struct btrfs_ioctl_search_args args;
500 struct btrfs_ioctl_search_key *sk = &args.key;
501 u64 last_pos = (u64)-1;
505 memset(&args, 0, sizeof(args));
506 sk->tree_id = BTRFS_DEV_TREE_OBJECTID;
507 sk->min_objectid = devid;
508 sk->max_objectid = devid;
509 sk->max_type = BTRFS_DEV_EXTENT_KEY;
510 sk->min_type = BTRFS_DEV_EXTENT_KEY;
512 sk->max_offset = (u64)-1;
514 sk->max_transid = (u64)-1;
519 struct btrfs_ioctl_search_header *sh;
520 unsigned long off = 0;
522 ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
524 error("tree search ioctl: %s", strerror(errno));
529 if (sk->nr_items == 0)
532 for (i = 0; i < sk->nr_items; i++) {
533 struct btrfs_dev_extent *extent;
536 sh = (struct btrfs_ioctl_search_header *)(args.buf +
539 extent = (struct btrfs_dev_extent *)(args.buf + off);
542 sk->min_objectid = sh->objectid;
543 sk->min_type = sh->type;
544 sk->min_offset = sh->offset + 1;
546 if (sh->objectid != devid ||
547 sh->type != BTRFS_DEV_EXTENT_KEY)
550 len = btrfs_stack_dev_extent_length(extent);
552 ret = add_dev_extent(&extents, sh->offset,
553 sh->offset + len - 1, 0);
555 if (!ret && last_pos != (u64)-1 &&
556 last_pos != sh->offset)
557 ret = add_dev_extent(&holes, last_pos,
560 error("add device extent: %s", strerror(-ret));
565 last_pos = sh->offset + len;
568 if (sk->min_type != BTRFS_DEV_EXTENT_KEY ||
569 sk->min_objectid != devid)
573 adjust_dev_min_size(&extents, &holes, &min_size);
574 printf("%llu bytes (%s)\n", min_size, pretty_size(min_size));
577 free_dev_extent_list(&extents);
578 free_dev_extent_list(&holes);
583 static int cmd_inspect_min_dev_size(int argc, char **argv)
587 DIR *dirstream = NULL;
592 enum { GETOPT_VAL_DEVID = 256 };
593 static const struct option long_options[] = {
594 { "id", required_argument, NULL, GETOPT_VAL_DEVID },
598 c = getopt_long(argc, argv, "", long_options, NULL);
603 case GETOPT_VAL_DEVID:
604 devid = arg_strtou64(optarg);
607 usage(cmd_inspect_min_dev_size_usage);
610 if (check_argc_exact(argc - optind, 1))
611 usage(cmd_inspect_min_dev_size_usage);
613 fd = btrfs_open_dir(argv[optind], &dirstream, 1);
619 ret = print_min_dev_size(fd, devid);
620 close_file_or_dir(fd, dirstream);
625 static const char inspect_cmd_group_info[] =
626 "query various internal information";
628 const struct cmd_group inspect_cmd_group = {
629 inspect_cmd_group_usage, inspect_cmd_group_info, {
630 { "inode-resolve", cmd_inspect_inode_resolve,
631 cmd_inspect_inode_resolve_usage, NULL, 0 },
632 { "logical-resolve", cmd_inspect_logical_resolve,
633 cmd_inspect_logical_resolve_usage, NULL, 0 },
634 { "subvolid-resolve", cmd_inspect_subvolid_resolve,
635 cmd_inspect_subvolid_resolve_usage, NULL, 0 },
636 { "rootid", cmd_inspect_rootid, cmd_inspect_rootid_usage, NULL,
638 { "min-dev-size", cmd_inspect_min_dev_size,
639 cmd_inspect_min_dev_size_usage, NULL, 0 },
640 { "dump-tree", cmd_inspect_dump_tree,
641 cmd_inspect_dump_tree_usage, NULL, 0 },
642 { "dump-super", cmd_inspect_dump_super,
643 cmd_inspect_dump_super_usage, NULL, 0 },
644 { "tree-stats", cmd_inspect_tree_stats,
645 cmd_inspect_tree_stats_usage, NULL, 0 },
650 int cmd_inspect(int argc, char **argv)
652 return handle_command_group(&inspect_cmd_group, argc, argv);