btrfs-map-logical.c

   1 /*
   2  * Copyright (C) 2009 Oracle.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 021110-1307, USA.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <fcntl.h>
  22 #include <unistd.h>
  23 #include <getopt.h>
  24 #include "kerncompat.h"
  25 #include "ctree.h"
  26 #include "volumes.h"
  27 #include "disk-io.h"
  28 #include "print-tree.h"
  29 #include "transaction.h"
  30 #include "list.h"
  31 #include "utils.h"
  32
  33 #define BUFFER_SIZE (64 * 1024)
  34
  35 /* we write the mirror info to stdout unless they are dumping the data
  36  * to stdout
  37  * */
  38 static FILE *info_file;
  39
  40 static int map_one_extent(struct btrfs_fs_info *fs_info,
  41                           u64 *logical_ret, u64 *len_ret, int search_foward)
  42 {
  43         struct btrfs_path *path;
  44         struct btrfs_key key;
  45         u64 logical;
  46         u64 len = 0;
  47         int ret = 0;
  48
  49         BUG_ON(!logical_ret);
  50         logical = *logical_ret;
  51
  52         path = btrfs_alloc_path();
  53         if (!path)
  54                 return -ENOMEM;
  55
  56         key.objectid = logical;
  57         key.type = 0;
  58         key.offset = 0;
  59
  60         ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, path,
  61                                 0, 0);
  62         if (ret < 0)
  63                 goto out;
  64         BUG_ON(ret == 0);
  65         ret = 0;
  66
  67 again:
  68         btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
  69         if ((search_foward && key.objectid < logical) ||
  70             (!search_foward && key.objectid > logical) ||
  71             (key.type != BTRFS_EXTENT_ITEM_KEY &&
  72              key.type != BTRFS_METADATA_ITEM_KEY)) {
  73                 if (!search_foward)
  74                         ret = btrfs_previous_extent_item(fs_info->extent_root,
  75                                                          path, 0);
  76                 else
  77                         ret = btrfs_next_item(fs_info->extent_root, path);
  78                 if (ret)
  79                         goto out;
  80                 goto again;
  81         }
  82         logical = key.objectid;
  83         if (key.type == BTRFS_METADATA_ITEM_KEY)
  84                 len = fs_info->tree_root->nodesize;
  85         else
  86                 len = key.offset;
  87
  88 out:
  89         btrfs_free_path(path);
  90         if (!ret) {
  91                 *logical_ret = logical;
  92                 if (len_ret)
  93                         *len_ret = len;
  94         }
  95         return ret;
  96 }
  97
  98 static int __print_mapping_info(struct btrfs_fs_info *fs_info, u64 logical,
  99                                 u64 len, int mirror_num)
 100 {
 101         struct btrfs_multi_bio *multi = NULL;
 102         u64 cur_offset = 0;
 103         u64 cur_len;
 104         int ret = 0;
 105
 106         while (cur_offset < len) {
 107                 struct btrfs_device *device;
 108                 int i;
 109
 110                 cur_len = len - cur_offset;
 111                 ret = btrfs_map_block(&fs_info->mapping_tree, READ,
 112                                 logical + cur_offset, &cur_len,
 113                                 &multi, mirror_num, NULL);
 114                 if (ret) {
 115                         fprintf(info_file,
 116                                 "Error: fails to map mirror%d logical %llu: %s\n",
 117                                 mirror_num, logical, strerror(-ret));
 118                         return ret;
 119                 }
 120                 for (i = 0; i < multi->num_stripes; i++) {
 121                         device = multi->stripes[i].dev;
 122                         fprintf(info_file,
 123                                 "mirror %d logical %Lu physical %Lu device %s\n",
 124                                 mirror_num, logical + cur_offset,
 125                                 multi->stripes[0].physical,
 126                                 device->name);
 127                 }
 128                 free(multi);
 129                 multi = NULL;
 130                 cur_offset += cur_len;
 131         }
 132         return ret;
 133 }
 134
 135 /*
 136  * Logical and len is the exact value of a extent.
 137  * And offset is the offset inside the extent. It's only used for case
 138  * where user only want to print part of the extent.
 139  *
 140  * Caller *MUST* ensure the range [logical,logical+len) are in one extent.
 141  * Or we can encounter the following case, causing a -ENOENT error:
 142  * |<-----given parameter------>|
 143  *              |<------ Extent A ----->|
 144  */
 145 static int print_mapping_info(struct btrfs_fs_info *fs_info, u64 logical,
 146                               u64 len)
 147 {
 148         int num_copies;
 149         int mirror_num;
 150         int ret = 0;
 151
 152         num_copies = btrfs_num_copies(&fs_info->mapping_tree, logical, len);
 153         for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) {
 154                 ret = __print_mapping_info(fs_info, logical, len, mirror_num);
 155                 if (ret < 0)
 156                         return ret;
 157         }
 158         return ret;
 159 }
 160
 161 /* Same requisition as print_mapping_info function */
 162 static int write_extent_content(struct btrfs_fs_info *fs_info, int out_fd,
 163                                 u64 logical, u64 length, int mirror)
 164 {
 165         char buffer[BUFFER_SIZE];
 166         u64 cur_offset = 0;
 167         u64 cur_len;
 168         int ret = 0;
 169
 170         while (cur_offset < length) {
 171                 cur_len = min_t(u64, length - cur_offset, BUFFER_SIZE);
 172                 ret = read_extent_data(fs_info->tree_root, buffer,
 173                                        logical + cur_offset, &cur_len, mirror);
 174                 if (ret < 0) {
 175                         fprintf(stderr,
 176                                 "Failed to read extent at [%llu, %llu]: %s\n",
 177                                 logical, logical + length, strerror(-ret));
 178                         return ret;
 179                 }
 180                 ret = write(out_fd, buffer, cur_len);
 181                 if (ret < 0 || ret != cur_len) {
 182                         if (ret > 0)
 183                                 ret = -EINTR;
 184                         fprintf(stderr, "output file write failed: %s\n",
 185                                 strerror(-ret));
 186                         return ret;
 187                 }
 188                 cur_offset += cur_len;
 189         }
 190         return ret;
 191 }
 192
 193 static void print_usage(void) __attribute__((noreturn));
 194 static void print_usage(void)
 195 {
 196         printf("usage: btrfs-map-logical [options] device\n");
 197         printf("\t-l Logical extent to map\n");
 198         printf("\t-c Copy of the extent to read (usually 1 or 2)\n");
 199         printf("\t-o Output file to hold the extent\n");
 200         printf("\t-b Number of bytes to read\n");
 201         exit(1);
 202 }
 203
 204 int main(int argc, char **argv)
 205 {
 206         struct cache_tree root_cache;
 207         struct btrfs_root *root;
 208         char *dev;
 209         char *output_file = NULL;
 210         u64 copy = 0;
 211         u64 logical = 0;
 212         u64 bytes = 0;
 213         u64 cur_logical = 0;
 214         u64 cur_len = 0;
 215         int out_fd = -1;
 216         int found = 0;
 217         int ret = 0;
 218
 219         while(1) {
 220                 int c;
 221                 static const struct option long_options[] = {
 222                         /* { "byte-count", 1, NULL, 'b' }, */
 223                         { "logical", required_argument, NULL, 'l' },
 224                         { "copy", required_argument, NULL, 'c' },
 225                         { "output", required_argument, NULL, 'o' },
 226                         { "bytes", required_argument, NULL, 'b' },
 227                         { NULL, 0, NULL, 0}
 228                 };
 229
 230                 c = getopt_long(argc, argv, "l:c:o:b:", long_options, NULL);
 231                 if (c < 0)
 232                         break;
 233                 switch(c) {
 234                         case 'l':
 235                                 logical = arg_strtou64(optarg);
 236                                 break;
 237                         case 'c':
 238                                 copy = arg_strtou64(optarg);
 239                                 break;
 240                         case 'b':
 241                                 bytes = arg_strtou64(optarg);
 242                                 break;
 243                         case 'o':
 244                                 output_file = strdup(optarg);
 245                                 break;
 246                         default:
 247                                 print_usage();
 248                 }
 249         }
 250         set_argv0(argv);
 251         if (check_argc_min(argc - optind, 1))
 252                 print_usage();
 253         if (logical == 0)
 254                 print_usage();
 255
 256         dev = argv[optind];
 257
 258         radix_tree_init();
 259         cache_tree_init(&root_cache);
 260
 261         root = open_ctree(dev, 0, 0);
 262         if (!root) {
 263                 fprintf(stderr, "Open ctree failed\n");
 264                 free(output_file);
 265                 exit(1);
 266         }
 267
 268         info_file = stdout;
 269         if (output_file) {
 270                 if (strcmp(output_file, "-") == 0) {
 271                         out_fd = 1;
 272                         info_file = stderr;
 273                 } else {
 274                         out_fd = open(output_file, O_RDWR | O_CREAT, 0600);
 275                         if (out_fd < 0)
 276                                 goto close;
 277                         ret = ftruncate(out_fd, 0);
 278                         if (ret) {
 279                                 ret = 1;
 280                                 close(out_fd);
 281                                 goto close;
 282                         }
 283                         info_file = stdout;
 284                 }
 285         }
 286
 287         if (bytes == 0)
 288                 bytes = root->nodesize;
 289         cur_logical = logical;
 290         cur_len = bytes;
 291
 292         /* First find the nearest extent */
 293         ret = map_one_extent(root->fs_info, &cur_logical, &cur_len, 0);
 294         if (ret < 0) {
 295                 fprintf(stderr, "Failed to find extent at [%llu,%llu): %s\n",
 296                         cur_logical, cur_logical + cur_len, strerror(-ret));
 297                 goto out_close_fd;
 298         }
 299         /*
 300          * Normally, search backward should be OK, but for special case like
 301          * given logical is quite small where no extents are before it,
 302          * we need to search forward.
 303          */
 304         if (ret > 0) {
 305                 ret = map_one_extent(root->fs_info, &cur_logical, &cur_len, 1);
 306                 if (ret < 0) {
 307                         fprintf(stderr,
 308                                 "Failed to find extent at [%llu,%llu): %s\n",
 309                                 cur_logical, cur_logical + cur_len,
 310                                 strerror(-ret));
 311                         goto out_close_fd;
 312                 }
 313                 if (ret > 0) {
 314                         fprintf(stderr,
 315                                 "Failed to find any extent at [%llu,%llu)\n",
 316                                 cur_logical, cur_logical + cur_len);
 317                         goto out_close_fd;
 318                 }
 319         }
 320
 321         while (cur_logical + cur_len >= logical && cur_logical < logical +
 322                bytes) {
 323                 u64 real_logical;
 324                 u64 real_len;
 325
 326                 found = 1;
 327                 ret = map_one_extent(root->fs_info, &cur_logical, &cur_len, 1);
 328                 if (ret < 0)
 329                         goto out_close_fd;
 330                 if (ret > 0)
 331                         break;
 332                 /* check again if there is overlap. */
 333                 if (cur_logical + cur_len < logical ||
 334                     cur_logical >= logical + bytes)
 335                         break;
 336
 337                 real_logical = max(logical, cur_logical);
 338                 real_len = min(logical + bytes, cur_logical + cur_len) -
 339                            real_logical;
 340
 341                 ret = print_mapping_info(root->fs_info, real_logical, real_len);
 342                 if (ret < 0)
 343                         goto out_close_fd;
 344                 if (output_file && out_fd != -1) {
 345                         ret = write_extent_content(root->fs_info, out_fd,
 346                                         real_logical, real_len, copy);
 347                         if (ret < 0)
 348                                 goto out_close_fd;
 349                 }
 350
 351                 cur_logical += cur_len;
 352         }
 353
 354         if (!found) {
 355                 fprintf(stderr, "No extent found at range [%llu,%llu)\n",
 356                         logical, logical + bytes);
 357         }
 358 out_close_fd:
 359         if (output_file && out_fd != 1)
 360                 close(out_fd);
 361 close:
 362         free(output_file);
 363         close_ctree(root);
 364         if (ret < 0)
 365                 ret = 1;
 366         btrfs_close_all_devices();
 367         return ret;
 368 }