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
  24 #include "kerncompat.h"
  25 #include "ioctl.h"
  26 #include "utils.h"
  27 #include "ctree.h"
  28 #include "send-utils.h"
  29
  30 #include "commands.h"
  31 #include "btrfs-list.h"
  32
  33 static const char * const inspect_cmd_group_usage[] = {
  34         "btrfs inspect-internal <command> <args>",
  35         NULL
  36 };
  37
  38 static int __ino_to_path_fd(u64 inum, int fd, int verbose, const char *prepend)
  39 {
  40         int ret;
  41         int i;
  42         struct btrfs_ioctl_ino_path_args ipa;
  43         struct btrfs_data_container *fspath;
  44
  45         fspath = malloc(4096);
  46         if (!fspath)
  47                 return -ENOMEM;
  48
  49         memset(fspath, 0, sizeof(*fspath));
  50         ipa.inum = inum;
  51         ipa.size = 4096;
  52         ipa.fspath = ptr_to_u64(fspath);
  53
  54         ret = ioctl(fd, BTRFS_IOC_INO_PATHS, &ipa);
  55         if (ret) {
  56                 printf("ioctl ret=%d, error: %s\n", ret, strerror(errno));
  57                 goto out;
  58         }
  59
  60         if (verbose)
  61                 printf("ioctl ret=%d, bytes_left=%lu, bytes_missing=%lu, "
  62                         "cnt=%d, missed=%d\n", ret,
  63                         (unsigned long)fspath->bytes_left,
  64                         (unsigned long)fspath->bytes_missing,
  65                         fspath->elem_cnt, fspath->elem_missed);
  66
  67         for (i = 0; i < fspath->elem_cnt; ++i) {
  68                 u64 ptr;
  69                 char *str;
  70                 ptr = (u64)(unsigned long)fspath->val;
  71                 ptr += fspath->val[i];
  72                 str = (char *)(unsigned long)ptr;
  73                 if (prepend)
  74                         printf("%s/%s\n", prepend, str);
  75                 else
  76                         printf("%s\n", str);
  77         }
  78
  79 out:
  80         free(fspath);
  81         return !!ret;
  82 }
  83
  84 static const char * const cmd_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_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_inode_resolve_usage);
 111                 }
 112         }
 113
 114         if (check_argc_exact(argc - optind, 2))
 115                 usage(cmd_inode_resolve_usage);
 116
 117         fd = open_file_or_dir(argv[optind+1], &dirstream);
 118         if (fd < 0) {
 119                 fprintf(stderr, "ERROR: can't access '%s'\n", argv[optind+1]);
 120                 return 1;
 121         }
 122
 123         ret = __ino_to_path_fd(arg_strtou64(argv[optind]), fd, verbose,
 124                                argv[optind+1]);
 125         close_file_or_dir(fd, dirstream);
 126         return !!ret;
 127
 128 }
 129
 130 static const char * const cmd_logical_resolve_usage[] = {
 131         "btrfs inspect-internal logical-resolve [-Pv] [-s bufsize] <logical> <path>",
 132         "Get file system paths for the given logical address",
 133         "-P          skip the path resolving and print the inodes instead",
 134         "-v          verbose mode",
 135         "-s bufsize  set inode container's size. This is used to increase inode",
 136         "            container's size in case it is not enough to read all the ",
 137         "            resolved results. The max value one can set is 64k",
 138         NULL
 139 };
 140
 141 static int cmd_logical_resolve(int argc, char **argv)
 142 {
 143         int ret;
 144         int fd;
 145         int i;
 146         int verbose = 0;
 147         int getpath = 1;
 148         int bytes_left;
 149         struct btrfs_ioctl_logical_ino_args loi;
 150         struct btrfs_data_container *inodes;
 151         u64 size = 4096;
 152         char full_path[4096];
 153         char *path_ptr;
 154         DIR *dirstream = NULL;
 155
 156         optind = 1;
 157         while (1) {
 158                 int c = getopt(argc, argv, "Pvs:");
 159                 if (c < 0)
 160                         break;
 161
 162                 switch (c) {
 163                 case 'P':
 164                         getpath = 0;
 165                         break;
 166                 case 'v':
 167                         verbose = 1;
 168                         break;
 169                 case 's':
 170                         size = arg_strtou64(optarg);
 171                         break;
 172                 default:
 173                         usage(cmd_logical_resolve_usage);
 174                 }
 175         }
 176
 177         if (check_argc_exact(argc - optind, 2))
 178                 usage(cmd_logical_resolve_usage);
 179
 180         size = min(size, (u64)64 * 1024);
 181         inodes = malloc(size);
 182         if (!inodes)
 183                 return 1;
 184
 185         memset(inodes, 0, sizeof(*inodes));
 186         loi.logical = arg_strtou64(argv[optind]);
 187         loi.size = size;
 188         loi.inodes = ptr_to_u64(inodes);
 189
 190         fd = open_file_or_dir(argv[optind+1], &dirstream);
 191         if (fd < 0) {
 192                 fprintf(stderr, "ERROR: can't access '%s'\n", argv[optind+1]);
 193                 ret = 12;
 194                 goto out;
 195         }
 196
 197         ret = ioctl(fd, BTRFS_IOC_LOGICAL_INO, &loi);
 198         if (ret) {
 199                 printf("ioctl ret=%d, error: %s\n", ret, strerror(errno));
 200                 goto out;
 201         }
 202
 203         if (verbose)
 204                 printf("ioctl ret=%d, total_size=%llu, bytes_left=%lu, "
 205                         "bytes_missing=%lu, cnt=%d, missed=%d\n",
 206                         ret, size,
 207                         (unsigned long)inodes->bytes_left,
 208                         (unsigned long)inodes->bytes_missing,
 209                         inodes->elem_cnt, inodes->elem_missed);
 210
 211         bytes_left = sizeof(full_path);
 212         ret = snprintf(full_path, bytes_left, "%s/", argv[optind+1]);
 213         path_ptr = full_path + ret;
 214         bytes_left -= ret + 1;
 215         BUG_ON(bytes_left < 0);
 216
 217         for (i = 0; i < inodes->elem_cnt; i += 3) {
 218                 u64 inum = inodes->val[i];
 219                 u64 offset = inodes->val[i+1];
 220                 u64 root = inodes->val[i+2];
 221                 int path_fd;
 222                 char *name;
 223                 DIR *dirs = NULL;
 224
 225                 if (getpath) {
 226                         name = btrfs_list_path_for_root(fd, root);
 227                         if (IS_ERR(name)) {
 228                                 ret = PTR_ERR(name);
 229                                 goto out;
 230                         }
 231                         if (!name) {
 232                                 path_ptr[-1] = '\0';
 233                                 path_fd = fd;
 234                         } else {
 235                                 path_ptr[-1] = '/';
 236                                 ret = snprintf(path_ptr, bytes_left, "%s",
 237                                                 name);
 238                                 BUG_ON(ret >= bytes_left);
 239                                 free(name);
 240                                 path_fd = open_file_or_dir(full_path, &dirs);
 241                                 if (path_fd < 0) {
 242                                         fprintf(stderr, "ERROR: can't access "
 243                                                 "'%s'\n", full_path);
 244                                         goto out;
 245                                 }
 246                         }
 247                         __ino_to_path_fd(inum, path_fd, verbose, full_path);
 248                         if (path_fd != fd)
 249                                 close_file_or_dir(path_fd, dirs);
 250                 } else {
 251                         printf("inode %llu offset %llu root %llu\n", inum,
 252                                 offset, root);
 253                 }
 254         }
 255
 256 out:
 257         close_file_or_dir(fd, dirstream);
 258         free(inodes);
 259         return !!ret;
 260 }
 261
 262 static const char * const cmd_subvolid_resolve_usage[] = {
 263         "btrfs inspect-internal subvolid-resolve <subvolid> <path>",
 264         "Get file system paths for the given subvolume ID.",
 265         NULL
 266 };
 267
 268 static int cmd_subvolid_resolve(int argc, char **argv)
 269 {
 270         int ret;
 271         int fd = -1;
 272         u64 subvol_id;
 273         char path[PATH_MAX];
 274         DIR *dirstream = NULL;
 275
 276         if (check_argc_exact(argc, 3))
 277                 usage(cmd_subvolid_resolve_usage);
 278
 279         fd = open_file_or_dir(argv[2], &dirstream);
 280         if (fd < 0) {
 281                 fprintf(stderr, "ERROR: can't access '%s'\n", argv[2]);
 282                 ret = -ENOENT;
 283                 goto out;
 284         }
 285
 286         subvol_id = arg_strtou64(argv[1]);
 287         ret = btrfs_subvolid_resolve(fd, path, sizeof(path), subvol_id);
 288
 289         if (ret) {
 290                 fprintf(stderr,
 291                         "%s: btrfs_subvolid_resolve(subvol_id %llu) failed with ret=%d\n",
 292                         argv[0], (unsigned long long)subvol_id, ret);
 293                 goto out;
 294         }
 295
 296         path[PATH_MAX] = '\0';
 297         printf("%s\n", path);
 298
 299 out:
 300         close_file_or_dir(fd, dirstream);
 301         return ret ? 1 : 0;
 302 }
 303
 304 static const char* const cmd_rootid_usage[] = {
 305         "btrfs inspect-internal rootid <path>",
 306         "Get tree ID of the containing subvolume of path.",
 307         NULL
 308 };
 309
 310 static int cmd_rootid(int argc, char **argv)
 311 {
 312         int ret;
 313         int fd = -1;
 314         u64 rootid;
 315         DIR *dirstream = NULL;
 316
 317         if (check_argc_exact(argc, 2))
 318                 usage(cmd_rootid_usage);
 319
 320         fd = open_file_or_dir(argv[1], &dirstream);
 321         if (fd < 0) {
 322                 fprintf(stderr, "ERROR: can't access '%s'\n", argv[1]);
 323                 ret = -ENOENT;
 324                 goto out;
 325         }
 326
 327         ret = lookup_ino_rootid(fd, &rootid);
 328         if (ret) {
 329                 fprintf(stderr, "%s: rootid failed with ret=%d\n",
 330                         argv[0], ret);
 331                 goto out;
 332         }
 333
 334         printf("%llu\n", (unsigned long long)rootid);
 335 out:
 336         close_file_or_dir(fd, dirstream);
 337
 338         return !!ret;
 339 }
 340
 341 static const char inspect_cmd_group_info[] =
 342 "query various internal information";
 343
 344 const struct cmd_group inspect_cmd_group = {
 345         inspect_cmd_group_usage, inspect_cmd_group_info, {
 346                 { "inode-resolve", cmd_inode_resolve, cmd_inode_resolve_usage,
 347                         NULL, 0 },
 348                 { "logical-resolve", cmd_logical_resolve,
 349                         cmd_logical_resolve_usage, NULL, 0 },
 350                 { "subvolid-resolve", cmd_subvolid_resolve,
 351                         cmd_subvolid_resolve_usage, NULL, 0 },
 352                 { "rootid", cmd_rootid, cmd_rootid_usage, NULL, 0 },
 353                 NULL_CMD_STRUCT
 354         }
 355 };
 356
 357 int cmd_inspect(int argc, char **argv)
 358 {
 359         return handle_command_group(&inspect_cmd_group, argc, argv);
 360 }