cmds-inspect.c

   1 /*
   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.
   5  *
   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.
  10  *
  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.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20 #include <stdint.h>
  21 #include <sys/ioctl.h>
  22 #include <errno.h>
  23 #include <getopt.h>
  24 #include <limits.h>
  25
  26 #include "kerncompat.h"
  27 #include "ioctl.h"
  28 #include "utils.h"
  29 #include "ctree.h"
  30 #include "send-utils.h"
  31 #include "disk-io.h"
  32 #include "commands.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"
  37
  38 static const char * const inspect_cmd_group_usage[] = {
  39         "btrfs inspect-internal <command> <args>",
  40         NULL
  41 };
  42
  43 static int __ino_to_path_fd(u64 inum, int fd, int verbose, const char *prepend)
  44 {
  45         int ret;
  46         int i;
  47         struct btrfs_ioctl_ino_path_args ipa;
  48         struct btrfs_data_container fspath[PATH_MAX];
  49
  50         memset(fspath, 0, sizeof(*fspath));
  51         ipa.inum = inum;
  52         ipa.size = PATH_MAX;
  53         ipa.fspath = ptr_to_u64(fspath);
  54
  55         ret = ioctl(fd, BTRFS_IOC_INO_PATHS, &ipa);
  56         if (ret < 0) {
  57                 error("ino paths ioctl: %s", strerror(errno));
  58                 goto out;
  59         }
  60
  61         if (verbose)
  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);
  67
  68         for (i = 0; i < fspath->elem_cnt; ++i) {
  69                 u64 ptr;
  70                 char *str;
  71                 ptr = (u64)(unsigned long)fspath->val;
  72                 ptr += fspath->val[i];
  73                 str = (char *)(unsigned long)ptr;
  74                 if (prepend)
  75                         printf("%s/%s\n", prepend, str);
  76                 else
  77                         printf("%s\n", str);
  78         }
  79
  80 out:
  81         return !!ret;
  82 }
  83
  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",
  87         "",
  88         "-v   verbose mode",
  89         NULL
  90 };
  91
  92 static int cmd_inspect_inode_resolve(int argc, char **argv)
  93 {
  94         int fd;
  95         int verbose = 0;
  96         int ret;
  97         DIR *dirstream = NULL;
  98
  99         optind = 1;
 100         while (1) {
 101                 int c = getopt(argc, argv, "v");
 102                 if (c < 0)
 103                         break;
 104
 105                 switch (c) {
 106                 case 'v':
 107                         verbose = 1;
 108                         break;
 109                 default:
 110                         usage(cmd_inspect_inode_resolve_usage);
 111                 }
 112         }
 113
 114         if (check_argc_exact(argc - optind, 2))
 115                 usage(cmd_inspect_inode_resolve_usage);
 116
 117         fd = btrfs_open_dir(argv[optind + 1], &dirstream, 1);
 118         if (fd < 0)
 119                 return 1;
 120
 121         ret = __ino_to_path_fd(arg_strtou64(argv[optind]), fd, verbose,
 122                                argv[optind+1]);
 123         close_file_or_dir(fd, dirstream);
 124         return !!ret;
 125
 126 }
 127
 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",
 132         "-v          verbose mode",
 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",
 136         NULL
 137 };
 138
 139 static int cmd_inspect_logical_resolve(int argc, char **argv)
 140 {
 141         int ret;
 142         int fd;
 143         int i;
 144         int verbose = 0;
 145         int getpath = 1;
 146         int bytes_left;
 147         struct btrfs_ioctl_logical_ino_args loi;
 148         struct btrfs_data_container *inodes;
 149         u64 size = 4096;
 150         char full_path[4096];
 151         char *path_ptr;
 152         DIR *dirstream = NULL;
 153
 154         optind = 1;
 155         while (1) {
 156                 int c = getopt(argc, argv, "Pvs:");
 157                 if (c < 0)
 158                         break;
 159
 160                 switch (c) {
 161                 case 'P':
 162                         getpath = 0;
 163                         break;
 164                 case 'v':
 165                         verbose = 1;
 166                         break;
 167                 case 's':
 168                         size = arg_strtou64(optarg);
 169                         break;
 170                 default:
 171                         usage(cmd_inspect_logical_resolve_usage);
 172                 }
 173         }
 174
 175         if (check_argc_exact(argc - optind, 2))
 176                 usage(cmd_inspect_logical_resolve_usage);
 177
 178         size = min(size, (u64)64 * 1024);
 179         inodes = malloc(size);
 180         if (!inodes)
 181                 return 1;
 182
 183         memset(inodes, 0, sizeof(*inodes));
 184         loi.logical = arg_strtou64(argv[optind]);
 185         loi.size = size;
 186         loi.inodes = ptr_to_u64(inodes);
 187
 188         fd = btrfs_open_dir(argv[optind + 1], &dirstream, 1);
 189         if (fd < 0) {
 190                 ret = 12;
 191                 goto out;
 192         }
 193
 194         ret = ioctl(fd, BTRFS_IOC_LOGICAL_INO, &loi);
 195         if (ret < 0) {
 196                 error("logical ino ioctl: %s", strerror(errno));
 197                 goto out;
 198         }
 199
 200         if (verbose)
 201                 printf("ioctl ret=%d, total_size=%llu, bytes_left=%lu, "
 202                         "bytes_missing=%lu, cnt=%d, missed=%d\n",
 203                         ret, size,
 204                         (unsigned long)inodes->bytes_left,
 205                         (unsigned long)inodes->bytes_missing,
 206                         inodes->elem_cnt, inodes->elem_missed);
 207
 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);
 213
 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];
 218                 int path_fd;
 219                 char *name;
 220                 DIR *dirs = NULL;
 221
 222                 if (getpath) {
 223                         name = btrfs_list_path_for_root(fd, root);
 224                         if (IS_ERR(name)) {
 225                                 ret = PTR_ERR(name);
 226                                 goto out;
 227                         }
 228                         if (!name) {
 229                                 path_ptr[-1] = '\0';
 230                                 path_fd = fd;
 231                         } else {
 232                                 path_ptr[-1] = '/';
 233                                 ret = snprintf(path_ptr, bytes_left, "%s",
 234                                                 name);
 235                                 BUG_ON(ret >= bytes_left);
 236                                 free(name);
 237                                 path_fd = btrfs_open_dir(full_path, &dirs, 1);
 238                                 if (path_fd < 0) {
 239                                         ret = -ENOENT;
 240                                         goto out;
 241                                 }
 242                         }
 243                         __ino_to_path_fd(inum, path_fd, verbose, full_path);
 244                         if (path_fd != fd)
 245                                 close_file_or_dir(path_fd, dirs);
 246                 } else {
 247                         printf("inode %llu offset %llu root %llu\n", inum,
 248                                 offset, root);
 249                 }
 250         }
 251
 252 out:
 253         close_file_or_dir(fd, dirstream);
 254         free(inodes);
 255         return !!ret;
 256 }
 257
 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.",
 261         NULL
 262 };
 263
 264 static int cmd_inspect_subvolid_resolve(int argc, char **argv)
 265 {
 266         int ret;
 267         int fd = -1;
 268         u64 subvol_id;
 269         char path[PATH_MAX];
 270         DIR *dirstream = NULL;
 271
 272         clean_args_no_options(argc, argv, cmd_inspect_subvolid_resolve_usage);
 273
 274         if (check_argc_exact(argc - optind, 2))
 275                 usage(cmd_inspect_subvolid_resolve_usage);
 276
 277         fd = btrfs_open_dir(argv[optind + 1], &dirstream, 1);
 278         if (fd < 0) {
 279                 ret = -ENOENT;
 280                 goto out;
 281         }
 282
 283         subvol_id = arg_strtou64(argv[optind]);
 284         ret = btrfs_subvolid_resolve(fd, path, sizeof(path), subvol_id);
 285
 286         if (ret) {
 287                 error("resolving subvolid %llu error %d",
 288                         (unsigned long long)subvol_id, ret);
 289                 goto out;
 290         }
 291
 292         path[PATH_MAX - 1] = '\0';
 293         printf("%s\n", path);
 294
 295 out:
 296         close_file_or_dir(fd, dirstream);
 297         return !!ret;
 298 }
 299
 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.",
 303         NULL
 304 };
 305
 306 static int cmd_inspect_rootid(int argc, char **argv)
 307 {
 308         int ret;
 309         int fd = -1;
 310         u64 rootid;
 311         DIR *dirstream = NULL;
 312
 313         clean_args_no_options(argc, argv, cmd_inspect_rootid_usage);
 314
 315         if (check_argc_exact(argc - optind, 1))
 316                 usage(cmd_inspect_rootid_usage);
 317
 318         fd = btrfs_open_dir(argv[optind], &dirstream, 1);
 319         if (fd < 0) {
 320                 ret = -ENOENT;
 321                 goto out;
 322         }
 323
 324         ret = lookup_ino_rootid(fd, &rootid);
 325         if (ret) {
 326                 error("rootid failed with ret=%d", ret);
 327                 goto out;
 328         }
 329
 330         printf("%llu\n", (unsigned long long)rootid);
 331 out:
 332         close_file_or_dir(fd, dirstream);
 333
 334         return !!ret;
 335 }
 336
 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",
 342         NULL
 343 };
 344
 345 struct dev_extent_elem {
 346         u64 start;
 347         /* inclusive end */
 348         u64 end;
 349         struct list_head list;
 350 };
 351
 352 static int add_dev_extent(struct list_head *list,
 353                           const u64 start, const u64 end,
 354                           const int append)
 355 {
 356         struct dev_extent_elem *e;
 357
 358         e = malloc(sizeof(*e));
 359         if (!e)
 360                 return -ENOMEM;
 361
 362         e->start = start;
 363         e->end = end;
 364
 365         if (append)
 366                 list_add_tail(&e->list, list);
 367         else
 368                 list_add(&e->list, list);
 369
 370         return 0;
 371 }
 372
 373 static void free_dev_extent_list(struct list_head *list)
 374 {
 375         while (!list_empty(list)) {
 376                 struct dev_extent_elem *e;
 377
 378                 e = list_first_entry(list, struct dev_extent_elem, list);
 379                 list_del(&e->list);
 380                 free(e);
 381         }
 382 }
 383
 384 static int hole_includes_sb_mirror(const u64 start, const u64 end)
 385 {
 386         int i;
 387         int ret = 0;
 388
 389         for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
 390                 u64 bytenr = btrfs_sb_offset(i);
 391
 392                 if (bytenr >= start && bytenr <= end) {
 393                         ret = 1;
 394                         break;
 395                 }
 396         }
 397
 398         return ret;
 399 }
 400
 401 static void adjust_dev_min_size(struct list_head *extents,
 402                                 struct list_head *holes,
 403                                 u64 *min_size)
 404 {
 405         /*
 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.
 412          */
 413         u64 scratch_space = 0;
 414
 415         /*
 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).
 421          */
 422         while (!list_empty(extents)) {
 423                 struct dev_extent_elem *e;
 424                 struct dev_extent_elem *h;
 425                 int found = 0;
 426                 u64 extent_len;
 427                 u64 hole_len = 0;
 428
 429                 e = list_first_entry(extents, struct dev_extent_elem, list);
 430                 if (e->end <= *min_size)
 431                         break;
 432
 433                 /*
 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.
 437                  */
 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) {
 442                                 found = 1;
 443                                 break;
 444                         }
 445                 }
 446
 447                 if (!found) {
 448                         *min_size = e->end + 1;
 449                         break;
 450                 }
 451
 452                 /*
 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).
 458                  */
 459                 if (hole_includes_sb_mirror(h->start,
 460                                             h->start + extent_len - 1))
 461                         *min_size += extent_len;
 462
 463                 if (hole_len > extent_len) {
 464                         h->start += extent_len;
 465                 } else {
 466                         list_del(&h->list);
 467                         free(h);
 468                 }
 469
 470                 list_del(&e->list);
 471                 free(e);
 472
 473                 if (extent_len > scratch_space)
 474                         scratch_space = extent_len;
 475         }
 476
 477         if (scratch_space) {
 478                 *min_size += scratch_space;
 479                 /*
 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.
 483                  */
 484                 *min_size += 32 * 1024 * 1024;
 485         }
 486 }
 487
 488 static int print_min_dev_size(int fd, u64 devid)
 489 {
 490         int ret = 1;
 491         /*
 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
 496          * ignore it here.
 497          */
 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;
 502         LIST_HEAD(extents);
 503         LIST_HEAD(holes);
 504
 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;
 511         sk->min_offset = 0;
 512         sk->max_offset = (u64)-1;
 513         sk->min_transid = 0;
 514         sk->max_transid = (u64)-1;
 515         sk->nr_items = 4096;
 516
 517         while (1) {
 518                 int i;
 519                 struct btrfs_ioctl_search_header *sh;
 520                 unsigned long off = 0;
 521
 522                 ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
 523                 if (ret < 0) {
 524                         error("tree search ioctl: %s", strerror(errno));
 525                         ret = 1;
 526                         goto out;
 527                 }
 528
 529                 if (sk->nr_items == 0)
 530                         break;
 531
 532                 for (i = 0; i < sk->nr_items; i++) {
 533                         struct btrfs_dev_extent *extent;
 534                         u64 len;
 535
 536                         sh = (struct btrfs_ioctl_search_header *)(args.buf +
 537                                                                   off);
 538                         off += sizeof(*sh);
 539                         extent = (struct btrfs_dev_extent *)(args.buf + off);
 540                         off += btrfs_search_header_len(sh);
 541
 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;
 545
 546                         if (btrfs_search_header_objectid(sh) != devid ||
 547                             btrfs_search_header_type(sh) != BTRFS_DEV_EXTENT_KEY)
 548                                 continue;
 549
 550                         len = btrfs_stack_dev_extent_length(extent);
 551                         min_size += len;
 552                         ret = add_dev_extent(&extents,
 553                                 btrfs_search_header_offset(sh),
 554                                 btrfs_search_header_offset(sh) + len - 1, 0);
 555
 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);
 560                         if (ret) {
 561                                 error("add device extent: %s", strerror(-ret));
 562                                 ret = 1;
 563                                 goto out;
 564                         }
 565
 566                         last_pos = btrfs_search_header_offset(sh) + len;
 567                 }
 568
 569                 if (sk->min_type != BTRFS_DEV_EXTENT_KEY ||
 570                     sk->min_objectid != devid)
 571                         break;
 572         }
 573
 574         adjust_dev_min_size(&extents, &holes, &min_size);
 575         printf("%llu bytes (%s)\n", min_size, pretty_size(min_size));
 576         ret = 0;
 577 out:
 578         free_dev_extent_list(&extents);
 579         free_dev_extent_list(&holes);
 580
 581         return ret;
 582 }
 583
 584 static int cmd_inspect_min_dev_size(int argc, char **argv)
 585 {
 586         int ret;
 587         int fd = -1;
 588         DIR *dirstream = NULL;
 589         u64 devid = 1;
 590
 591         while (1) {
 592                 int c;
 593                 enum { GETOPT_VAL_DEVID = 256 };
 594                 static const struct option long_options[] = {
 595                         { "id", required_argument, NULL, GETOPT_VAL_DEVID },
 596                         {NULL, 0, NULL, 0}
 597                 };
 598
 599                 c = getopt_long(argc, argv, "", long_options, NULL);
 600                 if (c < 0)
 601                         break;
 602
 603                 switch (c) {
 604                 case GETOPT_VAL_DEVID:
 605                         devid = arg_strtou64(optarg);
 606                         break;
 607                 default:
 608                         usage(cmd_inspect_min_dev_size_usage);
 609                 }
 610         }
 611         if (check_argc_exact(argc - optind, 1))
 612                 usage(cmd_inspect_min_dev_size_usage);
 613
 614         fd = btrfs_open_dir(argv[optind], &dirstream, 1);
 615         if (fd < 0) {
 616                 ret = -ENOENT;
 617                 goto out;
 618         }
 619
 620         ret = print_min_dev_size(fd, devid);
 621         close_file_or_dir(fd, dirstream);
 622 out:
 623         return !!ret;
 624 }
 625
 626 static const char inspect_cmd_group_info[] =
 627 "query various internal information";
 628
 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,
 638                         0 },
 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 },
 647                 NULL_CMD_STRUCT
 648         }
 649 };
 650
 651 int cmd_inspect(int argc, char **argv)
 652 {
 653         return handle_command_group(&inspect_cmd_group, argc, argv);
 654 }