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 "help.h"
  35
  36 static const char * const inspect_cmd_group_usage[] = {
  37         "btrfs inspect-internal <command> <args>",
  38         NULL
  39 };
  40
  41 static int __ino_to_path_fd(u64 inum, int fd, int verbose, const char *prepend)
  42 {
  43         int ret;
  44         int i;
  45         struct btrfs_ioctl_ino_path_args ipa;
  46         struct btrfs_data_container fspath[PATH_MAX];
  47
  48         memset(fspath, 0, sizeof(*fspath));
  49         ipa.inum = inum;
  50         ipa.size = PATH_MAX;
  51         ipa.fspath = ptr_to_u64(fspath);
  52
  53         ret = ioctl(fd, BTRFS_IOC_INO_PATHS, &ipa);
  54         if (ret < 0) {
  55                 error("ino paths ioctl: %m");
  56                 goto out;
  57         }
  58
  59         if (verbose)
  60                 printf("ioctl ret=%d, bytes_left=%lu, bytes_missing=%lu, "
  61                         "cnt=%d, missed=%d\n", ret,
  62                         (unsigned long)fspath->bytes_left,
  63                         (unsigned long)fspath->bytes_missing,
  64                         fspath->elem_cnt, fspath->elem_missed);
  65
  66         for (i = 0; i < fspath->elem_cnt; ++i) {
  67                 u64 ptr;
  68                 char *str;
  69                 ptr = (u64)(unsigned long)fspath->val;
  70                 ptr += fspath->val[i];
  71                 str = (char *)(unsigned long)ptr;
  72                 if (prepend)
  73                         printf("%s/%s\n", prepend, str);
  74                 else
  75                         printf("%s\n", str);
  76         }
  77
  78 out:
  79         return !!ret;
  80 }
  81
  82 static const char * const cmd_inspect_inode_resolve_usage[] = {
  83         "btrfs inspect-internal inode-resolve [-v] <inode> <path>",
  84         "Get file system paths for the given inode",
  85         "",
  86         "-v   verbose mode",
  87         NULL
  88 };
  89
  90 static int cmd_inspect_inode_resolve(int argc, char **argv)
  91 {
  92         int fd;
  93         int verbose = 0;
  94         int ret;
  95         DIR *dirstream = NULL;
  96
  97         optind = 0;
  98         while (1) {
  99                 int c = getopt(argc, argv, "v");
 100                 if (c < 0)
 101                         break;
 102
 103                 switch (c) {
 104                 case 'v':
 105                         verbose = 1;
 106                         break;
 107                 default:
 108                         usage(cmd_inspect_inode_resolve_usage);
 109                 }
 110         }
 111
 112         if (check_argc_exact(argc - optind, 2))
 113                 usage(cmd_inspect_inode_resolve_usage);
 114
 115         fd = btrfs_open_dir(argv[optind + 1], &dirstream, 1);
 116         if (fd < 0)
 117                 return 1;
 118
 119         ret = __ino_to_path_fd(arg_strtou64(argv[optind]), fd, verbose,
 120                                argv[optind+1]);
 121         close_file_or_dir(fd, dirstream);
 122         return !!ret;
 123
 124 }
 125
 126 static const char * const cmd_inspect_logical_resolve_usage[] = {
 127         "btrfs inspect-internal logical-resolve [-Pv] [-s bufsize] <logical> <path>",
 128         "Get file system paths for the given logical address",
 129         "-P          skip the path resolving and print the inodes instead",
 130         "-v          verbose mode",
 131         "-s bufsize  set inode container's size. This is used to increase inode",
 132         "            container's size in case it is not enough to read all the ",
 133         "            resolved results. The max value one can set is 64k",
 134         NULL
 135 };
 136
 137 static int cmd_inspect_logical_resolve(int argc, char **argv)
 138 {
 139         int ret;
 140         int fd;
 141         int i;
 142         int verbose = 0;
 143         int getpath = 1;
 144         int bytes_left;
 145         struct btrfs_ioctl_logical_ino_args loi;
 146         struct btrfs_data_container *inodes;
 147         u64 size = 4096;
 148         char full_path[PATH_MAX];
 149         char *path_ptr;
 150         DIR *dirstream = NULL;
 151
 152         optind = 0;
 153         while (1) {
 154                 int c = getopt(argc, argv, "Pvs:");
 155                 if (c < 0)
 156                         break;
 157
 158                 switch (c) {
 159                 case 'P':
 160                         getpath = 0;
 161                         break;
 162                 case 'v':
 163                         verbose = 1;
 164                         break;
 165                 case 's':
 166                         size = arg_strtou64(optarg);
 167                         break;
 168                 default:
 169                         usage(cmd_inspect_logical_resolve_usage);
 170                 }
 171         }
 172
 173         if (check_argc_exact(argc - optind, 2))
 174                 usage(cmd_inspect_logical_resolve_usage);
 175
 176         size = min(size, (u64)SZ_64K);
 177         inodes = malloc(size);
 178         if (!inodes)
 179                 return 1;
 180
 181         memset(inodes, 0, sizeof(*inodes));
 182         loi.logical = arg_strtou64(argv[optind]);
 183         loi.size = size;
 184         loi.inodes = ptr_to_u64(inodes);
 185
 186         fd = btrfs_open_dir(argv[optind + 1], &dirstream, 1);
 187         if (fd < 0) {
 188                 ret = 12;
 189                 goto out;
 190         }
 191
 192         ret = ioctl(fd, BTRFS_IOC_LOGICAL_INO, &loi);
 193         if (ret < 0) {
 194                 error("logical ino ioctl: %m");
 195                 goto out;
 196         }
 197
 198         if (verbose)
 199                 printf("ioctl ret=%d, total_size=%llu, bytes_left=%lu, "
 200                         "bytes_missing=%lu, cnt=%d, missed=%d\n",
 201                         ret, size,
 202                         (unsigned long)inodes->bytes_left,
 203                         (unsigned long)inodes->bytes_missing,
 204                         inodes->elem_cnt, inodes->elem_missed);
 205
 206         bytes_left = sizeof(full_path);
 207         ret = snprintf(full_path, bytes_left, "%s/", argv[optind+1]);
 208         path_ptr = full_path + ret;
 209         bytes_left -= ret + 1;
 210         if (bytes_left < 0) {
 211                 error("path buffer too small: %d bytes", bytes_left);
 212                 goto out;
 213         }
 214         ret = 0;
 215
 216         for (i = 0; i < inodes->elem_cnt; i += 3) {
 217                 u64 inum = inodes->val[i];
 218                 u64 offset = inodes->val[i+1];
 219                 u64 root = inodes->val[i+2];
 220                 int path_fd;
 221                 char *name;
 222                 DIR *dirs = NULL;
 223
 224                 if (getpath) {
 225                         name = btrfs_list_path_for_root(fd, root);
 226                         if (IS_ERR(name)) {
 227                                 ret = PTR_ERR(name);
 228                                 goto out;
 229                         }
 230                         if (!name) {
 231                                 path_ptr[-1] = '\0';
 232                                 path_fd = fd;
 233                         } else {
 234                                 path_ptr[-1] = '/';
 235                                 ret = snprintf(path_ptr, bytes_left, "%s",
 236                                                 name);
 237                                 free(name);
 238                                 if (ret >= bytes_left) {
 239                                         error("path buffer too small: %d bytes",
 240                                                         bytes_left - ret);
 241                                         goto out;
 242                                 }
 243                                 path_fd = btrfs_open_dir(full_path, &dirs, 1);
 244                                 if (path_fd < 0) {
 245                                         ret = -ENOENT;
 246                                         goto out;
 247                                 }
 248                         }
 249                         ret = __ino_to_path_fd(inum, path_fd, verbose,
 250                                                 full_path);
 251                         if (path_fd != fd)
 252                                 close_file_or_dir(path_fd, dirs);
 253                 } else {
 254                         printf("inode %llu offset %llu root %llu\n", inum,
 255                                 offset, root);
 256                 }
 257         }
 258
 259 out:
 260         close_file_or_dir(fd, dirstream);
 261         free(inodes);
 262         return !!ret;
 263 }
 264
 265 static const char * const cmd_inspect_subvolid_resolve_usage[] = {
 266         "btrfs inspect-internal subvolid-resolve <subvolid> <path>",
 267         "Get file system paths for the given subvolume ID.",
 268         NULL
 269 };
 270
 271 static int cmd_inspect_subvolid_resolve(int argc, char **argv)
 272 {
 273         int ret;
 274         int fd = -1;
 275         u64 subvol_id;
 276         char path[PATH_MAX];
 277         DIR *dirstream = NULL;
 278
 279         clean_args_no_options(argc, argv, cmd_inspect_subvolid_resolve_usage);
 280
 281         if (check_argc_exact(argc - optind, 2))
 282                 usage(cmd_inspect_subvolid_resolve_usage);
 283
 284         fd = btrfs_open_dir(argv[optind + 1], &dirstream, 1);
 285         if (fd < 0) {
 286                 ret = -ENOENT;
 287                 goto out;
 288         }
 289
 290         subvol_id = arg_strtou64(argv[optind]);
 291         ret = btrfs_subvolid_resolve(fd, path, sizeof(path), subvol_id);
 292
 293         if (ret) {
 294                 error("resolving subvolid %llu error %d",
 295                         (unsigned long long)subvol_id, ret);
 296                 goto out;
 297         }
 298
 299         path[PATH_MAX - 1] = '\0';
 300         printf("%s\n", path);
 301
 302 out:
 303         close_file_or_dir(fd, dirstream);
 304         return !!ret;
 305 }
 306
 307 static const char* const cmd_inspect_rootid_usage[] = {
 308         "btrfs inspect-internal rootid <path>",
 309         "Get tree ID of the containing subvolume of path.",
 310         NULL
 311 };
 312
 313 static int cmd_inspect_rootid(int argc, char **argv)
 314 {
 315         int ret;
 316         int fd = -1;
 317         u64 rootid;
 318         DIR *dirstream = NULL;
 319
 320         clean_args_no_options(argc, argv, cmd_inspect_rootid_usage);
 321
 322         if (check_argc_exact(argc - optind, 1))
 323                 usage(cmd_inspect_rootid_usage);
 324
 325         fd = btrfs_open_file_or_dir(argv[optind], &dirstream, 1);
 326         if (fd < 0) {
 327                 ret = -ENOENT;
 328                 goto out;
 329         }
 330
 331         ret = lookup_path_rootid(fd, &rootid);
 332         if (ret) {
 333                 error("failed to lookup root id: %s", strerror(-ret));
 334                 goto out;
 335         }
 336
 337         printf("%llu\n", (unsigned long long)rootid);
 338 out:
 339         close_file_or_dir(fd, dirstream);
 340
 341         return !!ret;
 342 }
 343
 344 static const char* const cmd_inspect_min_dev_size_usage[] = {
 345         "btrfs inspect-internal min-dev-size [options] <path>",
 346         "Get the minimum size the device can be shrunk to. The",
 347         "device id 1 is used by default.",
 348         "--id DEVID   specify the device id to query",
 349         NULL
 350 };
 351
 352 struct dev_extent_elem {
 353         u64 start;
 354         /* inclusive end */
 355         u64 end;
 356         struct list_head list;
 357 };
 358
 359 static int add_dev_extent(struct list_head *list,
 360                           const u64 start, const u64 end,
 361                           const int append)
 362 {
 363         struct dev_extent_elem *e;
 364
 365         e = malloc(sizeof(*e));
 366         if (!e)
 367                 return -ENOMEM;
 368
 369         e->start = start;
 370         e->end = end;
 371
 372         if (append)
 373                 list_add_tail(&e->list, list);
 374         else
 375                 list_add(&e->list, list);
 376
 377         return 0;
 378 }
 379
 380 static void free_dev_extent_list(struct list_head *list)
 381 {
 382         while (!list_empty(list)) {
 383                 struct dev_extent_elem *e;
 384
 385                 e = list_first_entry(list, struct dev_extent_elem, list);
 386                 list_del(&e->list);
 387                 free(e);
 388         }
 389 }
 390
 391 static int hole_includes_sb_mirror(const u64 start, const u64 end)
 392 {
 393         int i;
 394         int ret = 0;
 395
 396         for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
 397                 u64 bytenr = btrfs_sb_offset(i);
 398
 399                 if (bytenr >= start && bytenr <= end) {
 400                         ret = 1;
 401                         break;
 402                 }
 403         }
 404
 405         return ret;
 406 }
 407
 408 static void adjust_dev_min_size(struct list_head *extents,
 409                                 struct list_head *holes,
 410                                 u64 *min_size)
 411 {
 412         /*
 413          * If relocation of the block group of a device extent must happen (see
 414          * below) scratch space is used for the relocation. So track here the
 415          * size of the largest device extent that has to be relocated. We track
 416          * only the largest and not the sum of the sizes of all relocated block
 417          * groups because after each block group is relocated the running
 418          * transaction is committed so that pinned space is released.
 419          */
 420         u64 scratch_space = 0;
 421
 422         /*
 423          * List of device extents is sorted by descending order of the extent's
 424          * end offset. If some extent goes beyond the computed minimum size,
 425          * which initially matches the sum of the lengths of all extents,
 426          * we need to check if the extent can be relocated to an hole in the
 427          * device between [0, *min_size[ (which is what the resize ioctl does).
 428          */
 429         while (!list_empty(extents)) {
 430                 struct dev_extent_elem *e;
 431                 struct dev_extent_elem *h;
 432                 int found = 0;
 433                 u64 extent_len;
 434                 u64 hole_len = 0;
 435
 436                 e = list_first_entry(extents, struct dev_extent_elem, list);
 437                 if (e->end <= *min_size)
 438                         break;
 439
 440                 /*
 441                  * Our extent goes beyond the computed *min_size. See if we can
 442                  * find a hole large enough to relocate it to. If not we must stop
 443                  * and set *min_size to the end of the extent.
 444                  */
 445                 extent_len = e->end - e->start + 1;
 446                 list_for_each_entry(h, holes, list) {
 447                         hole_len = h->end - h->start + 1;
 448                         if (hole_len >= extent_len) {
 449                                 found = 1;
 450                                 break;
 451                         }
 452                 }
 453
 454                 if (!found) {
 455                         *min_size = e->end + 1;
 456                         break;
 457                 }
 458
 459                 /*
 460                  * If the hole found contains the location for a superblock
 461                  * mirror, we are pessimistic and require allocating one
 462                  * more extent of the same size. This is because the block
 463                  * group could be in the worst case used by a single extent
 464                  * with a size >= (block_group.length - superblock.size).
 465                  */
 466                 if (hole_includes_sb_mirror(h->start,
 467                                             h->start + extent_len - 1))
 468                         *min_size += extent_len;
 469
 470                 if (hole_len > extent_len) {
 471                         h->start += extent_len;
 472                 } else {
 473                         list_del(&h->list);
 474                         free(h);
 475                 }
 476
 477                 list_del(&e->list);
 478                 free(e);
 479
 480                 if (extent_len > scratch_space)
 481                         scratch_space = extent_len;
 482         }
 483
 484         if (scratch_space) {
 485                 *min_size += scratch_space;
 486                 /*
 487                  * Chunk allocation requires inserting/updating items in the
 488                  * chunk tree, so often this can lead to the need of allocating
 489                  * a new system chunk too, which has a maximum size of 32Mb.
 490                  */
 491                 *min_size += SZ_32M;
 492         }
 493 }
 494
 495 static int print_min_dev_size(int fd, u64 devid)
 496 {
 497         int ret = 1;
 498         /*
 499          * Device allocations starts at 1Mb or at the value passed through the
 500          * mount option alloc_start if it's bigger than 1Mb. The alloc_start
 501          * option is used for debugging and testing only, and recently the
 502          * possibility of deprecating/removing it has been discussed, so we
 503          * ignore it here.
 504          */
 505         u64 min_size = SZ_1M;
 506         struct btrfs_ioctl_search_args args;
 507         struct btrfs_ioctl_search_key *sk = &args.key;
 508         u64 last_pos = (u64)-1;
 509         LIST_HEAD(extents);
 510         LIST_HEAD(holes);
 511
 512         memset(&args, 0, sizeof(args));
 513         sk->tree_id = BTRFS_DEV_TREE_OBJECTID;
 514         sk->min_objectid = devid;
 515         sk->max_objectid = devid;
 516         sk->max_type = BTRFS_DEV_EXTENT_KEY;
 517         sk->min_type = BTRFS_DEV_EXTENT_KEY;
 518         sk->min_offset = 0;
 519         sk->max_offset = (u64)-1;
 520         sk->min_transid = 0;
 521         sk->max_transid = (u64)-1;
 522         sk->nr_items = 4096;
 523
 524         while (1) {
 525                 int i;
 526                 struct btrfs_ioctl_search_header *sh;
 527                 unsigned long off = 0;
 528
 529                 ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
 530                 if (ret < 0) {
 531                         error("tree search ioctl: %m");
 532                         ret = 1;
 533                         goto out;
 534                 }
 535
 536                 if (sk->nr_items == 0)
 537                         break;
 538
 539                 for (i = 0; i < sk->nr_items; i++) {
 540                         struct btrfs_dev_extent *extent;
 541                         u64 len;
 542
 543                         sh = (struct btrfs_ioctl_search_header *)(args.buf +
 544                                                                   off);
 545                         off += sizeof(*sh);
 546                         extent = (struct btrfs_dev_extent *)(args.buf + off);
 547                         off += btrfs_search_header_len(sh);
 548
 549                         sk->min_objectid = btrfs_search_header_objectid(sh);
 550                         sk->min_type = btrfs_search_header_type(sh);
 551                         sk->min_offset = btrfs_search_header_offset(sh) + 1;
 552
 553                         if (btrfs_search_header_objectid(sh) != devid ||
 554                             btrfs_search_header_type(sh) != BTRFS_DEV_EXTENT_KEY)
 555                                 continue;
 556
 557                         len = btrfs_stack_dev_extent_length(extent);
 558                         min_size += len;
 559                         ret = add_dev_extent(&extents,
 560                                 btrfs_search_header_offset(sh),
 561                                 btrfs_search_header_offset(sh) + len - 1, 0);
 562
 563                         if (!ret && last_pos != (u64)-1 &&
 564                             last_pos != btrfs_search_header_offset(sh))
 565                                 ret = add_dev_extent(&holes, last_pos,
 566                                         btrfs_search_header_offset(sh) - 1, 1);
 567                         if (ret) {
 568                                 error("add device extent: %s", strerror(-ret));
 569                                 ret = 1;
 570                                 goto out;
 571                         }
 572
 573                         last_pos = btrfs_search_header_offset(sh) + len;
 574                 }
 575
 576                 if (sk->min_type != BTRFS_DEV_EXTENT_KEY ||
 577                     sk->min_objectid != devid)
 578                         break;
 579         }
 580
 581         adjust_dev_min_size(&extents, &holes, &min_size);
 582         printf("%llu bytes (%s)\n", min_size, pretty_size(min_size));
 583         ret = 0;
 584 out:
 585         free_dev_extent_list(&extents);
 586         free_dev_extent_list(&holes);
 587
 588         return ret;
 589 }
 590
 591 static int cmd_inspect_min_dev_size(int argc, char **argv)
 592 {
 593         int ret;
 594         int fd = -1;
 595         DIR *dirstream = NULL;
 596         u64 devid = 1;
 597
 598         optind = 0;
 599         while (1) {
 600                 int c;
 601                 enum { GETOPT_VAL_DEVID = 256 };
 602                 static const struct option long_options[] = {
 603                         { "id", required_argument, NULL, GETOPT_VAL_DEVID },
 604                         {NULL, 0, NULL, 0}
 605                 };
 606
 607                 c = getopt_long(argc, argv, "", long_options, NULL);
 608                 if (c < 0)
 609                         break;
 610
 611                 switch (c) {
 612                 case GETOPT_VAL_DEVID:
 613                         devid = arg_strtou64(optarg);
 614                         break;
 615                 default:
 616                         usage(cmd_inspect_min_dev_size_usage);
 617                 }
 618         }
 619         if (check_argc_exact(argc - optind, 1))
 620                 usage(cmd_inspect_min_dev_size_usage);
 621
 622         fd = btrfs_open_dir(argv[optind], &dirstream, 1);
 623         if (fd < 0) {
 624                 ret = -ENOENT;
 625                 goto out;
 626         }
 627
 628         ret = print_min_dev_size(fd, devid);
 629         close_file_or_dir(fd, dirstream);
 630 out:
 631         return !!ret;
 632 }
 633
 634 static const char inspect_cmd_group_info[] =
 635 "query various internal information";
 636
 637 const struct cmd_group inspect_cmd_group = {
 638         inspect_cmd_group_usage, inspect_cmd_group_info, {
 639                 { "inode-resolve", cmd_inspect_inode_resolve,
 640                         cmd_inspect_inode_resolve_usage, NULL, 0 },
 641                 { "logical-resolve", cmd_inspect_logical_resolve,
 642                         cmd_inspect_logical_resolve_usage, NULL, 0 },
 643                 { "subvolid-resolve", cmd_inspect_subvolid_resolve,
 644                         cmd_inspect_subvolid_resolve_usage, NULL, 0 },
 645                 { "rootid", cmd_inspect_rootid, cmd_inspect_rootid_usage, NULL,
 646                         0 },
 647                 { "min-dev-size", cmd_inspect_min_dev_size,
 648                         cmd_inspect_min_dev_size_usage, NULL, 0 },
 649                 { "dump-tree", cmd_inspect_dump_tree,
 650                                 cmd_inspect_dump_tree_usage, NULL, 0 },
 651                 { "dump-super", cmd_inspect_dump_super,
 652                                 cmd_inspect_dump_super_usage, NULL, 0 },
 653                 { "tree-stats", cmd_inspect_tree_stats,
 654                                 cmd_inspect_tree_stats_usage, NULL, 0 },
 655                 NULL_CMD_STRUCT
 656         }
 657 };
 658
 659 int cmd_inspect(int argc, char **argv)
 660 {
 661         return handle_command_group(&inspect_cmd_group, argc, argv);
 662 }