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 lengths 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
);
540 off
+= btrfs_search_header_len(sh
);
542 sk
->min_objectid
= btrfs_search_header_objectid(sh
);
543 sk
->min_type
= btrfs_search_header_type(sh
);
544 sk
->min_offset
= btrfs_search_header_offset(sh
) + 1;
546 if (btrfs_search_header_objectid(sh
) != devid
||
547 btrfs_search_header_type(sh
) != BTRFS_DEV_EXTENT_KEY
)
550 len
= btrfs_stack_dev_extent_length(extent
);
552 ret
= add_dev_extent(&extents
,
553 btrfs_search_header_offset(sh
),
554 btrfs_search_header_offset(sh
) + len
- 1, 0);
556 if (!ret
&& last_pos
!= (u64
)-1 &&
557 last_pos
!= btrfs_search_header_offset(sh
))
558 ret
= add_dev_extent(&holes
, last_pos
,
559 btrfs_search_header_offset(sh
) - 1, 1);
561 error("add device extent: %s", strerror(-ret
));
566 last_pos
= btrfs_search_header_offset(sh
) + len
;
569 if (sk
->min_type
!= BTRFS_DEV_EXTENT_KEY
||
570 sk
->min_objectid
!= devid
)
574 adjust_dev_min_size(&extents
, &holes
, &min_size
);
575 printf("%llu bytes (%s)\n", min_size
, pretty_size(min_size
));
578 free_dev_extent_list(&extents
);
579 free_dev_extent_list(&holes
);
584 static int cmd_inspect_min_dev_size(int argc
, char **argv
)
588 DIR *dirstream
= NULL
;
593 enum { GETOPT_VAL_DEVID
= 256 };
594 static const struct option long_options
[] = {
595 { "id", required_argument
, NULL
, GETOPT_VAL_DEVID
},
599 c
= getopt_long(argc
, argv
, "", long_options
, NULL
);
604 case GETOPT_VAL_DEVID
:
605 devid
= arg_strtou64(optarg
);
608 usage(cmd_inspect_min_dev_size_usage
);
611 if (check_argc_exact(argc
- optind
, 1))
612 usage(cmd_inspect_min_dev_size_usage
);
614 fd
= btrfs_open_dir(argv
[optind
], &dirstream
, 1);
620 ret
= print_min_dev_size(fd
, devid
);
621 close_file_or_dir(fd
, dirstream
);
626 static const char inspect_cmd_group_info
[] =
627 "query various internal information";
629 const struct cmd_group inspect_cmd_group
= {
630 inspect_cmd_group_usage
, inspect_cmd_group_info
, {
631 { "inode-resolve", cmd_inspect_inode_resolve
,
632 cmd_inspect_inode_resolve_usage
, NULL
, 0 },
633 { "logical-resolve", cmd_inspect_logical_resolve
,
634 cmd_inspect_logical_resolve_usage
, NULL
, 0 },
635 { "subvolid-resolve", cmd_inspect_subvolid_resolve
,
636 cmd_inspect_subvolid_resolve_usage
, NULL
, 0 },
637 { "rootid", cmd_inspect_rootid
, cmd_inspect_rootid_usage
, NULL
,
639 { "min-dev-size", cmd_inspect_min_dev_size
,
640 cmd_inspect_min_dev_size_usage
, NULL
, 0 },
641 { "dump-tree", cmd_inspect_dump_tree
,
642 cmd_inspect_dump_tree_usage
, NULL
, 0 },
643 { "dump-super", cmd_inspect_dump_super
,
644 cmd_inspect_dump_super_usage
, NULL
, 0 },
645 { "tree-stats", cmd_inspect_tree_stats
,
646 cmd_inspect_tree_stats_usage
, NULL
, 0 },
651 int cmd_inspect(int argc
, char **argv
)
653 return handle_command_group(&inspect_cmd_group
, argc
, argv
);