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