btrfs-image.c

   1 /*
   2  * Copyright (C) 2008 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 #define _XOPEN_SOURCE 500
  20 #define _GNU_SOURCE 1
  21 #include <pthread.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <unistd.h>
  28 #include <dirent.h>
  29 #include <zlib.h>
  30 #include "kerncompat.h"
  31 #include "crc32c.h"
  32 #include "ctree.h"
  33 #include "disk-io.h"
  34 #include "transaction.h"
  35 #include "utils.h"
  36 #include "version.h"
  37 #include "volumes.h"
  38
  39 #define HEADER_MAGIC            0xbd5c25e27295668bULL
  40 #define MAX_PENDING_SIZE        (256 * 1024)
  41 #define BLOCK_SIZE              1024
  42 #define BLOCK_MASK              (BLOCK_SIZE - 1)
  43
  44 #define COMPRESS_NONE           0
  45 #define COMPRESS_ZLIB           1
  46
  47 struct meta_cluster_item {
  48         __le64 bytenr;
  49         __le32 size;
  50 } __attribute__ ((__packed__));
  51
  52 struct meta_cluster_header {
  53         __le64 magic;
  54         __le64 bytenr;
  55         __le32 nritems;
  56         u8 compress;
  57 } __attribute__ ((__packed__));
  58
  59 /* cluster header + index items + buffers */
  60 struct meta_cluster {
  61         struct meta_cluster_header header;
  62         struct meta_cluster_item items[];
  63 } __attribute__ ((__packed__));
  64
  65 #define ITEMS_PER_CLUSTER ((BLOCK_SIZE - sizeof(struct meta_cluster)) / \
  66                            sizeof(struct meta_cluster_item))
  67
  68 struct async_work {
  69         struct list_head list;
  70         struct list_head ordered;
  71         u64 start;
  72         u64 size;
  73         u8 *buffer;
  74         size_t bufsize;
  75         int error;
  76 };
  77
  78 struct metadump_struct {
  79         struct btrfs_root *root;
  80         FILE *out;
  81
  82         struct meta_cluster *cluster;
  83
  84         pthread_t *threads;
  85         size_t num_threads;
  86         pthread_mutex_t mutex;
  87         pthread_cond_t cond;
  88
  89         struct list_head list;
  90         struct list_head ordered;
  91         size_t num_items;
  92         size_t num_ready;
  93
  94         u64 pending_start;
  95         u64 pending_size;
  96
  97         int compress_level;
  98         int done;
  99         int data;
 100 };
 101
 102 struct mdrestore_struct {
 103         FILE *in;
 104         FILE *out;
 105
 106         pthread_t *threads;
 107         size_t num_threads;
 108         pthread_mutex_t mutex;
 109         pthread_cond_t cond;
 110
 111         struct list_head list;
 112         size_t num_items;
 113         u64 leafsize;
 114         u64 devid;
 115         u8 uuid[BTRFS_UUID_SIZE];
 116         u8 fsid[BTRFS_FSID_SIZE];
 117
 118         int compress_method;
 119         int done;
 120         int error;
 121         int old_restore;
 122 };
 123
 124 static void csum_block(u8 *buf, size_t len)
 125 {
 126         char result[BTRFS_CRC32_SIZE];
 127         u32 crc = ~(u32)0;
 128         crc = crc32c(crc, buf + BTRFS_CSUM_SIZE, len - BTRFS_CSUM_SIZE);
 129         btrfs_csum_final(crc, result);
 130         memcpy(buf, result, BTRFS_CRC32_SIZE);
 131 }
 132
 133 /*
 134  * zero inline extents and csum items
 135  */
 136 static void zero_items(u8 *dst, struct extent_buffer *src)
 137 {
 138         struct btrfs_file_extent_item *fi;
 139         struct btrfs_item *item;
 140         struct btrfs_key key;
 141         u32 nritems = btrfs_header_nritems(src);
 142         size_t size;
 143         unsigned long ptr;
 144         int i, extent_type;
 145
 146         for (i = 0; i < nritems; i++) {
 147                 item = btrfs_item_nr(src, i);
 148                 btrfs_item_key_to_cpu(src, &key, i);
 149                 if (key.type == BTRFS_CSUM_ITEM_KEY) {
 150                         size = btrfs_item_size_nr(src, i);
 151                         memset(dst + btrfs_leaf_data(src) +
 152                                btrfs_item_offset_nr(src, i), 0, size);
 153                         continue;
 154                 }
 155                 if (key.type != BTRFS_EXTENT_DATA_KEY)
 156                         continue;
 157
 158                 fi = btrfs_item_ptr(src, i, struct btrfs_file_extent_item);
 159                 extent_type = btrfs_file_extent_type(src, fi);
 160                 if (extent_type != BTRFS_FILE_EXTENT_INLINE)
 161                         continue;
 162
 163                 ptr = btrfs_file_extent_inline_start(fi);
 164                 size = btrfs_file_extent_inline_item_len(src, item);
 165                 memset(dst + ptr, 0, size);
 166         }
 167 }
 168
 169 /*
 170  * copy buffer and zero useless data in the buffer
 171  */
 172 static void copy_buffer(u8 *dst, struct extent_buffer *src)
 173 {
 174         int level;
 175         size_t size;
 176         u32 nritems;
 177
 178         memcpy(dst, src->data, src->len);
 179         if (src->start == BTRFS_SUPER_INFO_OFFSET)
 180                 return;
 181
 182         level = btrfs_header_level(src);
 183         nritems = btrfs_header_nritems(src);
 184
 185         if (nritems == 0) {
 186                 size = sizeof(struct btrfs_header);
 187                 memset(dst + size, 0, src->len - size);
 188         } else if (level == 0) {
 189                 size = btrfs_leaf_data(src) +
 190                         btrfs_item_offset_nr(src, nritems - 1) -
 191                         btrfs_item_nr_offset(nritems);
 192                 memset(dst + btrfs_item_nr_offset(nritems), 0, size);
 193                 zero_items(dst, src);
 194         } else {
 195                 size = offsetof(struct btrfs_node, ptrs) +
 196                         sizeof(struct btrfs_key_ptr) * nritems;
 197                 memset(dst + size, 0, src->len - size);
 198         }
 199         csum_block(dst, src->len);
 200 }
 201
 202 static void *dump_worker(void *data)
 203 {
 204         struct metadump_struct *md = (struct metadump_struct *)data;
 205         struct async_work *async;
 206         int ret;
 207
 208         while (1) {
 209                 pthread_mutex_lock(&md->mutex);
 210                 while (list_empty(&md->list)) {
 211                         if (md->done) {
 212                                 pthread_mutex_unlock(&md->mutex);
 213                                 goto out;
 214                         }
 215                         pthread_cond_wait(&md->cond, &md->mutex);
 216                 }
 217                 async = list_entry(md->list.next, struct async_work, list);
 218                 list_del_init(&async->list);
 219                 pthread_mutex_unlock(&md->mutex);
 220
 221                 if (md->compress_level > 0) {
 222                         u8 *orig = async->buffer;
 223
 224                         async->bufsize = compressBound(async->size);
 225                         async->buffer = malloc(async->bufsize);
 226
 227                         ret = compress2(async->buffer,
 228                                          (unsigned long *)&async->bufsize,
 229                                          orig, async->size, md->compress_level);
 230
 231                         if (ret != Z_OK)
 232                                 async->error = 1;
 233
 234                         free(orig);
 235                 }
 236
 237                 pthread_mutex_lock(&md->mutex);
 238                 md->num_ready++;
 239                 pthread_mutex_unlock(&md->mutex);
 240         }
 241 out:
 242         pthread_exit(NULL);
 243 }
 244
 245 static void meta_cluster_init(struct metadump_struct *md, u64 start)
 246 {
 247         struct meta_cluster_header *header;
 248
 249         md->num_items = 0;
 250         md->num_ready = 0;
 251         header = &md->cluster->header;
 252         header->magic = cpu_to_le64(HEADER_MAGIC);
 253         header->bytenr = cpu_to_le64(start);
 254         header->nritems = cpu_to_le32(0);
 255         header->compress = md->compress_level > 0 ?
 256                            COMPRESS_ZLIB : COMPRESS_NONE;
 257 }
 258
 259 static int metadump_init(struct metadump_struct *md, struct btrfs_root *root,
 260                          FILE *out, int num_threads, int compress_level)
 261 {
 262         int i, ret = 0;
 263
 264         memset(md, 0, sizeof(*md));
 265         pthread_cond_init(&md->cond, NULL);
 266         pthread_mutex_init(&md->mutex, NULL);
 267         INIT_LIST_HEAD(&md->list);
 268         INIT_LIST_HEAD(&md->ordered);
 269         md->root = root;
 270         md->out = out;
 271         md->pending_start = (u64)-1;
 272         md->compress_level = compress_level;
 273         md->cluster = calloc(1, BLOCK_SIZE);
 274         if (!md->cluster) {
 275                 pthread_cond_destroy(&md->cond);
 276                 pthread_mutex_destroy(&md->mutex);
 277                 return -ENOMEM;
 278         }
 279
 280         meta_cluster_init(md, 0);
 281         if (!num_threads)
 282                 return 0;
 283
 284         md->num_threads = num_threads;
 285         md->threads = calloc(num_threads, sizeof(pthread_t));
 286         if (!md->threads) {
 287                 free(md->cluster);
 288                 pthread_cond_destroy(&md->cond);
 289                 pthread_mutex_destroy(&md->mutex);
 290                 return -ENOMEM;
 291         }
 292
 293         for (i = 0; i < num_threads; i++) {
 294                 ret = pthread_create(md->threads + i, NULL, dump_worker, md);
 295                 if (ret)
 296                         break;
 297         }
 298
 299         if (ret) {
 300                 pthread_mutex_lock(&md->mutex);
 301                 md->done = 1;
 302                 pthread_cond_broadcast(&md->cond);
 303                 pthread_mutex_unlock(&md->mutex);
 304
 305                 for (i--; i >= 0; i--)
 306                         pthread_join(md->threads[i], NULL);
 307
 308                 pthread_cond_destroy(&md->cond);
 309                 pthread_mutex_destroy(&md->mutex);
 310                 free(md->cluster);
 311                 free(md->threads);
 312         }
 313
 314         return ret;
 315 }
 316
 317 static void metadump_destroy(struct metadump_struct *md)
 318 {
 319         int i;
 320         pthread_mutex_lock(&md->mutex);
 321         md->done = 1;
 322         pthread_cond_broadcast(&md->cond);
 323         pthread_mutex_unlock(&md->mutex);
 324
 325         for (i = 0; i < md->num_threads; i++)
 326                 pthread_join(md->threads[i], NULL);
 327
 328         pthread_cond_destroy(&md->cond);
 329         pthread_mutex_destroy(&md->mutex);
 330         free(md->threads);
 331         free(md->cluster);
 332 }
 333
 334 static int write_zero(FILE *out, size_t size)
 335 {
 336         static char zero[BLOCK_SIZE];
 337         return fwrite(zero, size, 1, out);
 338 }
 339
 340 static int write_buffers(struct metadump_struct *md, u64 *next)
 341 {
 342         struct meta_cluster_header *header = &md->cluster->header;
 343         struct meta_cluster_item *item;
 344         struct async_work *async;
 345         u64 bytenr = 0;
 346         u32 nritems = 0;
 347         int ret;
 348         int err = 0;
 349
 350         if (list_empty(&md->ordered))
 351                 goto out;
 352
 353         /* wait until all buffers are compressed */
 354         while (md->num_items > md->num_ready) {
 355                 struct timespec ts = {
 356                         .tv_sec = 0,
 357                         .tv_nsec = 10000000,
 358                 };
 359                 pthread_mutex_unlock(&md->mutex);
 360                 nanosleep(&ts, NULL);
 361                 pthread_mutex_lock(&md->mutex);
 362         }
 363
 364         /* setup and write index block */
 365         list_for_each_entry(async, &md->ordered, ordered) {
 366                 item = md->cluster->items + nritems;
 367                 item->bytenr = cpu_to_le64(async->start);
 368                 item->size = cpu_to_le32(async->bufsize);
 369                 nritems++;
 370         }
 371         header->nritems = cpu_to_le32(nritems);
 372
 373         ret = fwrite(md->cluster, BLOCK_SIZE, 1, md->out);
 374         if (ret != 1) {
 375                 fprintf(stderr, "Error writing out cluster: %d\n", errno);
 376                 return -EIO;
 377         }
 378
 379         /* write buffers */
 380         bytenr += le64_to_cpu(header->bytenr) + BLOCK_SIZE;
 381         while (!list_empty(&md->ordered)) {
 382                 async = list_entry(md->ordered.next, struct async_work,
 383                                    ordered);
 384                 list_del_init(&async->ordered);
 385
 386                 bytenr += async->bufsize;
 387                 if (!err)
 388                         ret = fwrite(async->buffer, async->bufsize, 1,
 389                                      md->out);
 390                 if (ret != 1) {
 391                         err = -EIO;
 392                         ret = 0;
 393                         fprintf(stderr, "Error writing out cluster: %d\n",
 394                                 errno);
 395                 }
 396
 397                 free(async->buffer);
 398                 free(async);
 399         }
 400
 401         /* zero unused space in the last block */
 402         if (!err && bytenr & BLOCK_MASK) {
 403                 size_t size = BLOCK_SIZE - (bytenr & BLOCK_MASK);
 404
 405                 bytenr += size;
 406                 ret = write_zero(md->out, size);
 407                 if (ret != 1) {
 408                         fprintf(stderr, "Error zeroing out buffer: %d\n",
 409                                 errno);
 410                         err = -EIO;
 411                 }
 412         }
 413 out:
 414         *next = bytenr;
 415         return err;
 416 }
 417
 418 static int read_data_extent(struct metadump_struct *md,
 419                             struct async_work *async)
 420 {
 421         struct btrfs_multi_bio *multi = NULL;
 422         struct btrfs_device *device;
 423         u64 bytes_left = async->size;
 424         u64 logical = async->start;
 425         u64 offset = 0;
 426         u64 bytenr;
 427         u64 read_len;
 428         ssize_t done;
 429         int fd;
 430         int ret;
 431
 432         while (bytes_left) {
 433                 read_len = bytes_left;
 434                 ret = btrfs_map_block(&md->root->fs_info->mapping_tree, READ,
 435                                       logical, &read_len, &multi, 0, NULL);
 436                 if (ret) {
 437                         fprintf(stderr, "Couldn't map data block %d\n", ret);
 438                         return ret;
 439                 }
 440
 441                 device = multi->stripes[0].dev;
 442
 443                 if (device->fd == 0) {
 444                         fprintf(stderr,
 445                                 "Device we need to read from is not open\n");
 446                         free(multi);
 447                         return -EIO;
 448                 }
 449                 fd = device->fd;
 450                 bytenr = multi->stripes[0].physical;
 451                 free(multi);
 452
 453                 read_len = min(read_len, bytes_left);
 454                 done = pread64(fd, async->buffer+offset, read_len, bytenr);
 455                 if (done < read_len) {
 456                         if (done < 0)
 457                                 fprintf(stderr, "Error reading extent %d\n",
 458                                         errno);
 459                         else
 460                                 fprintf(stderr, "Short read\n");
 461                         return -EIO;
 462                 }
 463
 464                 bytes_left -= done;
 465                 offset += done;
 466                 logical += done;
 467         }
 468
 469         return 0;
 470 }
 471
 472 static int flush_pending(struct metadump_struct *md, int done)
 473 {
 474         struct async_work *async = NULL;
 475         struct extent_buffer *eb;
 476         u64 blocksize = md->root->nodesize;
 477         u64 start;
 478         u64 size;
 479         size_t offset;
 480         int ret = 0;
 481
 482         if (md->pending_size) {
 483                 async = calloc(1, sizeof(*async));
 484                 if (!async)
 485                         return -ENOMEM;
 486
 487                 async->start = md->pending_start;
 488                 async->size = md->pending_size;
 489                 async->bufsize = async->size;
 490                 async->buffer = malloc(async->bufsize);
 491                 if (!async->buffer) {
 492                         free(async);
 493                         return -ENOMEM;
 494                 }
 495                 offset = 0;
 496                 start = async->start;
 497                 size = async->size;
 498
 499                 if (md->data) {
 500                         ret = read_data_extent(md, async);
 501                         if (ret) {
 502                                 free(async->buffer);
 503                                 free(async);
 504                                 return ret;
 505                         }
 506                 }
 507
 508                 while (!md->data && size > 0) {
 509                         u64 this_read = min(blocksize, size);
 510                         eb = read_tree_block(md->root, start, this_read, 0);
 511                         if (!eb) {
 512                                 free(async->buffer);
 513                                 free(async);
 514                                 fprintf(stderr,
 515                                         "Error reading metadata block\n");
 516                                 return -EIO;
 517                         }
 518                         copy_buffer(async->buffer + offset, eb);
 519                         free_extent_buffer(eb);
 520                         start += this_read;
 521                         offset += this_read;
 522                         size -= this_read;
 523                 }
 524
 525                 md->pending_start = (u64)-1;
 526                 md->pending_size = 0;
 527         } else if (!done) {
 528                 return 0;
 529         }
 530
 531         pthread_mutex_lock(&md->mutex);
 532         if (async) {
 533                 list_add_tail(&async->ordered, &md->ordered);
 534                 md->num_items++;
 535                 if (md->compress_level > 0) {
 536                         list_add_tail(&async->list, &md->list);
 537                         pthread_cond_signal(&md->cond);
 538                 } else {
 539                         md->num_ready++;
 540                 }
 541         }
 542         if (md->num_items >= ITEMS_PER_CLUSTER || done) {
 543                 ret = write_buffers(md, &start);
 544                 if (ret)
 545                         fprintf(stderr, "Error writing buffers %d\n",
 546                                 errno);
 547                 else
 548                         meta_cluster_init(md, start);
 549         }
 550         pthread_mutex_unlock(&md->mutex);
 551         return ret;
 552 }
 553
 554 static int add_extent(u64 start, u64 size, struct metadump_struct *md,
 555                       int data)
 556 {
 557         int ret;
 558         if (md->data != data ||
 559             md->pending_size + size > MAX_PENDING_SIZE ||
 560             md->pending_start + md->pending_size != start) {
 561                 ret = flush_pending(md, 0);
 562                 if (ret)
 563                         return ret;
 564                 md->pending_start = start;
 565         }
 566         readahead_tree_block(md->root, start, size, 0);
 567         md->pending_size += size;
 568         md->data = data;
 569         return 0;
 570 }
 571
 572 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
 573 static int is_tree_block(struct btrfs_root *extent_root,
 574                          struct btrfs_path *path, u64 bytenr)
 575 {
 576         struct extent_buffer *leaf;
 577         struct btrfs_key key;
 578         u64 ref_objectid;
 579         int ret;
 580
 581         leaf = path->nodes[0];
 582         while (1) {
 583                 struct btrfs_extent_ref_v0 *ref_item;
 584                 path->slots[0]++;
 585                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
 586                         ret = btrfs_next_leaf(extent_root, path);
 587                         if (ret < 0)
 588                                 return ret;
 589                         if (ret > 0)
 590                                 break;
 591                         leaf = path->nodes[0];
 592                 }
 593                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 594                 if (key.objectid != bytenr)
 595                         break;
 596                 if (key.type != BTRFS_EXTENT_REF_V0_KEY)
 597                         continue;
 598                 ref_item = btrfs_item_ptr(leaf, path->slots[0],
 599                                           struct btrfs_extent_ref_v0);
 600                 ref_objectid = btrfs_ref_objectid_v0(leaf, ref_item);
 601                 if (ref_objectid < BTRFS_FIRST_FREE_OBJECTID)
 602                         return 1;
 603                 break;
 604         }
 605         return 0;
 606 }
 607 #endif
 608
 609 static int copy_tree_blocks(struct btrfs_root *root, struct extent_buffer *eb,
 610                             struct metadump_struct *metadump, int root_tree)
 611 {
 612         struct extent_buffer *tmp;
 613         struct btrfs_root_item *ri;
 614         struct btrfs_key key;
 615         u64 bytenr;
 616         int level;
 617         int nritems = 0;
 618         int i = 0;
 619         int ret;
 620
 621         ret = add_extent(btrfs_header_bytenr(eb), root->leafsize, metadump, 0);
 622         if (ret) {
 623                 fprintf(stderr, "Error adding metadata block\n");
 624                 return ret;
 625         }
 626
 627         if (btrfs_header_level(eb) == 0 && !root_tree)
 628                 return 0;
 629
 630         level = btrfs_header_level(eb);
 631         nritems = btrfs_header_nritems(eb);
 632         for (i = 0; i < nritems; i++) {
 633                 if (level == 0) {
 634                         btrfs_item_key_to_cpu(eb, &key, i);
 635                         if (key.type != BTRFS_ROOT_ITEM_KEY)
 636                                 continue;
 637                         ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
 638                         bytenr = btrfs_disk_root_bytenr(eb, ri);
 639                         tmp = read_tree_block(root, bytenr, root->leafsize, 0);
 640                         if (!tmp) {
 641                                 fprintf(stderr,
 642                                         "Error reading log root block\n");
 643                                 return -EIO;
 644                         }
 645                         ret = copy_tree_blocks(root, tmp, metadump, 0);
 646                         free_extent_buffer(tmp);
 647                         if (ret)
 648                                 return ret;
 649                 } else {
 650                         bytenr = btrfs_node_blockptr(eb, i);
 651                         tmp = read_tree_block(root, bytenr, root->leafsize, 0);
 652                         if (!tmp) {
 653                                 fprintf(stderr, "Error reading log block\n");
 654                                 return -EIO;
 655                         }
 656                         ret = copy_tree_blocks(root, tmp, metadump, root_tree);
 657                         free_extent_buffer(tmp);
 658                         if (ret)
 659                                 return ret;
 660                 }
 661         }
 662
 663         return 0;
 664 }
 665
 666 static int copy_log_trees(struct btrfs_root *root,
 667                           struct metadump_struct *metadump,
 668                           struct btrfs_path *path)
 669 {
 670         u64 blocknr = btrfs_super_log_root(root->fs_info->super_copy);
 671
 672         if (blocknr == 0)
 673                 return 0;
 674
 675         if (!root->fs_info->log_root_tree ||
 676             !root->fs_info->log_root_tree->node) {
 677                 fprintf(stderr, "Error copying tree log, it wasn't setup\n");
 678                 return -EIO;
 679         }
 680
 681         return copy_tree_blocks(root, root->fs_info->log_root_tree->node,
 682                                 metadump, 1);
 683 }
 684
 685 static int copy_space_cache(struct btrfs_root *root,
 686                             struct metadump_struct *metadump,
 687                             struct btrfs_path *path)
 688 {
 689         struct extent_buffer *leaf;
 690         struct btrfs_file_extent_item *fi;
 691         struct btrfs_key key;
 692         u64 bytenr, num_bytes;
 693         int ret;
 694
 695         root = root->fs_info->tree_root;
 696
 697         key.objectid = 0;
 698         key.type = BTRFS_EXTENT_DATA_KEY;
 699         key.offset = 0;
 700
 701         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 702         if (ret < 0) {
 703                 fprintf(stderr, "Error searching for free space inode %d\n",
 704                         ret);
 705                 return ret;
 706         }
 707
 708         while (1) {
 709                 leaf = path->nodes[0];
 710                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
 711                         ret = btrfs_next_leaf(root, path);
 712                         if (ret < 0) {
 713                                 fprintf(stderr, "Error going to next leaf "
 714                                         "%d\n", ret);
 715                                 return ret;
 716                         }
 717                         if (ret > 0)
 718                                 break;
 719                         leaf = path->nodes[0];
 720                 }
 721
 722                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 723                 if (key.type != BTRFS_EXTENT_DATA_KEY) {
 724                         path->slots[0]++;
 725                         continue;
 726                 }
 727
 728                 fi = btrfs_item_ptr(leaf, path->slots[0],
 729                                     struct btrfs_file_extent_item);
 730                 if (btrfs_file_extent_type(leaf, fi) !=
 731                     BTRFS_FILE_EXTENT_REG) {
 732                         path->slots[0]++;
 733                         continue;
 734                 }
 735
 736                 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
 737                 num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
 738                 ret = add_extent(bytenr, num_bytes, metadump, 1);
 739                 if (ret) {
 740                         fprintf(stderr, "Error adding space cache blocks %d\n",
 741                                 ret);
 742                         btrfs_release_path(root, path);
 743                         return ret;
 744                 }
 745                 path->slots[0]++;
 746         }
 747
 748         return 0;
 749 }
 750
 751 static int copy_from_extent_tree(struct metadump_struct *metadump,
 752                                  struct btrfs_path *path)
 753 {
 754         struct btrfs_root *extent_root;
 755         struct extent_buffer *leaf;
 756         struct btrfs_extent_item *ei;
 757         struct btrfs_key key;
 758         u64 bytenr;
 759         u64 num_bytes;
 760         int ret;
 761
 762         extent_root = metadump->root->fs_info->extent_root;
 763         bytenr = BTRFS_SUPER_INFO_OFFSET + 4096;
 764         key.objectid = bytenr;
 765         key.type = BTRFS_EXTENT_ITEM_KEY;
 766         key.offset = 0;
 767
 768         ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
 769         if (ret < 0) {
 770                 fprintf(stderr, "Error searching extent root %d\n", ret);
 771                 return ret;
 772         }
 773         ret = 0;
 774
 775         while (1) {
 776                 leaf = path->nodes[0];
 777                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
 778                         ret = btrfs_next_leaf(extent_root, path);
 779                         if (ret < 0) {
 780                                 fprintf(stderr, "Error going to next leaf %d"
 781                                         "\n", ret);
 782                                 break;
 783                         }
 784                         if (ret > 0) {
 785                                 ret = 0;
 786                                 break;
 787                         }
 788                         leaf = path->nodes[0];
 789                 }
 790
 791                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 792                 if (key.objectid < bytenr ||
 793                     (key.type != BTRFS_EXTENT_ITEM_KEY &&
 794                      key.type != BTRFS_METADATA_ITEM_KEY)) {
 795                         path->slots[0]++;
 796                         continue;
 797                 }
 798
 799                 bytenr = key.objectid;
 800                 if (key.type == BTRFS_METADATA_ITEM_KEY)
 801                         num_bytes = key.offset;
 802                 else
 803                         num_bytes = extent_root->leafsize;
 804
 805                 if (btrfs_item_size_nr(leaf, path->slots[0]) > sizeof(*ei)) {
 806                         ei = btrfs_item_ptr(leaf, path->slots[0],
 807                                             struct btrfs_extent_item);
 808                         if (btrfs_extent_flags(leaf, ei) &
 809                             BTRFS_EXTENT_FLAG_TREE_BLOCK) {
 810                                 ret = add_extent(bytenr, num_bytes, metadump,
 811                                                  0);
 812                                 if (ret) {
 813                                         fprintf(stderr, "Error adding block "
 814                                                 "%d\n", ret);
 815                                         break;
 816                                 }
 817                         }
 818                 } else {
 819 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
 820                         ret = is_tree_block(extent_root, path, bytenr);
 821                         if (ret < 0) {
 822                                 fprintf(stderr, "Error checking tree block "
 823                                         "%d\n", ret);
 824                                 break;
 825                         }
 826
 827                         if (ret) {
 828                                 ret = add_extent(bytenr, num_bytes, metadump,
 829                                                  0);
 830                                 if (ret) {
 831                                         fprintf(stderr, "Error adding block "
 832                                                 "%d\n", ret);
 833                                         break;
 834                                 }
 835                         }
 836                         ret = 0;
 837 #else
 838                         fprintf(stderr, "Either extent tree corruption or "
 839                                 "you haven't built with V0 support\n");
 840                         ret = -EIO;
 841                         break;
 842 #endif
 843                 }
 844                 bytenr += num_bytes;
 845         }
 846
 847         btrfs_release_path(extent_root, path);
 848
 849         return ret;
 850 }
 851
 852 static int create_metadump(const char *input, FILE *out, int num_threads,
 853                            int compress_level, int walk_trees)
 854 {
 855         struct btrfs_root *root;
 856         struct btrfs_path *path = NULL;
 857         struct metadump_struct metadump;
 858         int ret;
 859         int err = 0;
 860
 861         root = open_ctree(input, 0, 0);
 862         if (!root) {
 863                 fprintf(stderr, "Open ctree failed\n");
 864                 return -EIO;
 865         }
 866
 867         BUG_ON(root->nodesize != root->leafsize);
 868
 869         ret = metadump_init(&metadump, root, out, num_threads,
 870                             compress_level);
 871         if (ret) {
 872                 fprintf(stderr, "Error initing metadump %d\n", ret);
 873                 close_ctree(root);
 874                 return ret;
 875         }
 876
 877         ret = add_extent(BTRFS_SUPER_INFO_OFFSET, 4096, &metadump, 0);
 878         if (ret) {
 879                 fprintf(stderr, "Error adding metadata %d\n", ret);
 880                 err = ret;
 881                 goto out;
 882         }
 883
 884         path = btrfs_alloc_path();
 885         if (!path) {
 886                 fprintf(stderr, "Out of memory allocing path\n");
 887                 err = -ENOMEM;
 888                 goto out;
 889         }
 890
 891         if (walk_trees) {
 892                 ret = copy_tree_blocks(root, root->fs_info->chunk_root->node,
 893                                        &metadump, 1);
 894                 if (ret) {
 895                         err = ret;
 896                         goto out;
 897                 }
 898
 899                 ret = copy_tree_blocks(root, root->fs_info->tree_root->node,
 900                                        &metadump, 1);
 901                 if (ret) {
 902                         err = ret;
 903                         goto out;
 904                 }
 905         } else {
 906                 ret = copy_from_extent_tree(&metadump, path);
 907                 if (ret) {
 908                         err = ret;
 909                         goto out;
 910                 }
 911         }
 912
 913         ret = copy_log_trees(root, &metadump, path);
 914         if (ret) {
 915                 err = ret;
 916                 goto out;
 917         }
 918
 919         ret = copy_space_cache(root, &metadump, path);
 920 out:
 921         ret = flush_pending(&metadump, 1);
 922         if (ret) {
 923                 if (!err)
 924                         err = ret;
 925                 fprintf(stderr, "Error flushing pending %d\n", ret);
 926         }
 927
 928         metadump_destroy(&metadump);
 929
 930         btrfs_free_path(path);
 931         ret = close_ctree(root);
 932         return err ? err : ret;
 933 }
 934
 935 static void update_super_old(u8 *buffer)
 936 {
 937         struct btrfs_super_block *super = (struct btrfs_super_block *)buffer;
 938         struct btrfs_chunk *chunk;
 939         struct btrfs_disk_key *key;
 940         u32 sectorsize = btrfs_super_sectorsize(super);
 941         u64 flags = btrfs_super_flags(super);
 942
 943         flags |= BTRFS_SUPER_FLAG_METADUMP;
 944         btrfs_set_super_flags(super, flags);
 945
 946         key = (struct btrfs_disk_key *)(super->sys_chunk_array);
 947         chunk = (struct btrfs_chunk *)(super->sys_chunk_array +
 948                                        sizeof(struct btrfs_disk_key));
 949
 950         btrfs_set_disk_key_objectid(key, BTRFS_FIRST_CHUNK_TREE_OBJECTID);
 951         btrfs_set_disk_key_type(key, BTRFS_CHUNK_ITEM_KEY);
 952         btrfs_set_disk_key_offset(key, 0);
 953
 954         btrfs_set_stack_chunk_length(chunk, (u64)-1);
 955         btrfs_set_stack_chunk_owner(chunk, BTRFS_EXTENT_TREE_OBJECTID);
 956         btrfs_set_stack_chunk_stripe_len(chunk, 64 * 1024);
 957         btrfs_set_stack_chunk_type(chunk, BTRFS_BLOCK_GROUP_SYSTEM);
 958         btrfs_set_stack_chunk_io_align(chunk, sectorsize);
 959         btrfs_set_stack_chunk_io_width(chunk, sectorsize);
 960         btrfs_set_stack_chunk_sector_size(chunk, sectorsize);
 961         btrfs_set_stack_chunk_num_stripes(chunk, 1);
 962         btrfs_set_stack_chunk_sub_stripes(chunk, 0);
 963         chunk->stripe.devid = super->dev_item.devid;
 964         chunk->stripe.offset = cpu_to_le64(0);
 965         memcpy(chunk->stripe.dev_uuid, super->dev_item.uuid, BTRFS_UUID_SIZE);
 966         btrfs_set_super_sys_array_size(super, sizeof(*key) + sizeof(*chunk));
 967         csum_block(buffer, 4096);
 968 }
 969
 970 static int update_super(u8 *buffer)
 971 {
 972         struct btrfs_super_block *super = (struct btrfs_super_block *)buffer;
 973         struct btrfs_chunk *chunk;
 974         struct btrfs_disk_key *disk_key;
 975         struct btrfs_key key;
 976         u32 new_array_size = 0;
 977         u32 array_size;
 978         u32 cur = 0;
 979         u32 new_cur = 0;
 980         u8 *ptr, *write_ptr;
 981         int old_num_stripes;
 982
 983         write_ptr = ptr = super->sys_chunk_array;
 984         array_size = btrfs_super_sys_array_size(super);
 985
 986         while (cur < array_size) {
 987                 disk_key = (struct btrfs_disk_key *)ptr;
 988                 btrfs_disk_key_to_cpu(&key, disk_key);
 989
 990                 new_array_size += sizeof(*disk_key);
 991                 memmove(write_ptr, ptr, sizeof(*disk_key));
 992
 993                 write_ptr += sizeof(*disk_key);
 994                 ptr += sizeof(*disk_key);
 995                 cur += sizeof(*disk_key);
 996                 new_cur += sizeof(*disk_key);
 997
 998                 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
 999                         chunk = (struct btrfs_chunk *)ptr;
1000                         old_num_stripes = btrfs_stack_chunk_num_stripes(chunk);
1001                         chunk = (struct btrfs_chunk *)write_ptr;
1002
1003                         memmove(write_ptr, ptr, sizeof(*chunk));
1004                         btrfs_set_stack_chunk_num_stripes(chunk, 1);
1005                         btrfs_set_stack_chunk_sub_stripes(chunk, 0);
1006                         btrfs_set_stack_chunk_type(chunk,
1007                                                    BTRFS_BLOCK_GROUP_SYSTEM);
1008                         chunk->stripe.devid = super->dev_item.devid;
1009                         chunk->stripe.offset = cpu_to_le64(key.offset);
1010                         memcpy(chunk->stripe.dev_uuid, super->dev_item.uuid,
1011                                BTRFS_UUID_SIZE);
1012                         new_array_size += sizeof(*chunk);
1013                         new_cur += sizeof(*chunk);
1014                 } else {
1015                         fprintf(stderr, "Bogus key in the sys chunk array "
1016                                 "%d\n", key.type);
1017                         return -EIO;
1018                 }
1019                 write_ptr += sizeof(*chunk);
1020                 ptr += btrfs_chunk_item_size(old_num_stripes);
1021                 cur += btrfs_chunk_item_size(old_num_stripes);
1022         }
1023
1024         btrfs_set_super_sys_array_size(super, new_array_size);
1025         csum_block(buffer, 4096);
1026
1027         return 0;
1028 }
1029
1030 static struct extent_buffer *alloc_dummy_eb(u64 bytenr, u32 size)
1031 {
1032         struct extent_buffer *eb;
1033
1034         eb = malloc(sizeof(struct extent_buffer) + size);
1035         if (!eb)
1036                 return NULL;
1037         memset(eb, 0, sizeof(struct extent_buffer) + size);
1038
1039         eb->start = bytenr;
1040         eb->len = size;
1041         return eb;
1042 }
1043
1044 static void truncate_item(struct extent_buffer *eb, int slot, u32 new_size)
1045 {
1046         struct btrfs_item *item;
1047         u32 nritems;
1048         u32 old_size;
1049         u32 old_data_start;
1050         u32 size_diff;
1051         u32 data_end;
1052         int i;
1053
1054         old_size = btrfs_item_size_nr(eb, slot);
1055         if (old_size == new_size)
1056                 return;
1057
1058         nritems = btrfs_header_nritems(eb);
1059         data_end = btrfs_item_offset_nr(eb, nritems - 1);
1060
1061         old_data_start = btrfs_item_offset_nr(eb, slot);
1062         size_diff = old_size - new_size;
1063
1064         for (i = slot; i < nritems; i++) {
1065                 u32 ioff;
1066                 item = btrfs_item_nr(eb, i);
1067                 ioff = btrfs_item_offset(eb, item);
1068                 btrfs_set_item_offset(eb, item, ioff + size_diff);
1069         }
1070
1071         memmove_extent_buffer(eb, btrfs_leaf_data(eb) + data_end + size_diff,
1072                               btrfs_leaf_data(eb) + data_end,
1073                               old_data_start + new_size - data_end);
1074         item = btrfs_item_nr(eb, slot);
1075         btrfs_set_item_size(eb, item, new_size);
1076 }
1077
1078 static int fixup_chunk_tree_block(struct mdrestore_struct *mdres,
1079                                   struct async_work *async, u8 *buffer,
1080                                   size_t size)
1081 {
1082         struct extent_buffer *eb;
1083         size_t size_left = size;
1084         u64 bytenr = async->start;
1085         int i;
1086
1087         if (size_left % mdres->leafsize)
1088                 return 0;
1089
1090         eb = alloc_dummy_eb(bytenr, mdres->leafsize);
1091         if (!eb)
1092                 return -ENOMEM;
1093
1094         while (size_left) {
1095                 eb->start = bytenr;
1096                 memcpy(eb->data, buffer, mdres->leafsize);
1097
1098                 if (btrfs_header_bytenr(eb) != bytenr)
1099                         break;
1100                 if (memcmp(mdres->fsid,
1101                            eb->data + offsetof(struct btrfs_header, fsid),
1102                            BTRFS_FSID_SIZE))
1103                         break;
1104
1105                 if (btrfs_header_owner(eb) != BTRFS_CHUNK_TREE_OBJECTID)
1106                         goto next;
1107
1108                 if (btrfs_header_level(eb) != 0)
1109                         goto next;
1110
1111                 for (i = 0; i < btrfs_header_nritems(eb); i++) {
1112                         struct btrfs_chunk chunk;
1113                         struct btrfs_key key;
1114                         u64 type;
1115
1116                         btrfs_item_key_to_cpu(eb, &key, i);
1117                         if (key.type != BTRFS_CHUNK_ITEM_KEY)
1118                                 continue;
1119                         truncate_item(eb, i, sizeof(chunk));
1120                         read_extent_buffer(eb, &chunk,
1121                                            btrfs_item_ptr_offset(eb, i),
1122                                            sizeof(chunk));
1123
1124                         /* Zero out the RAID profile */
1125                         type = btrfs_stack_chunk_type(&chunk);
1126                         type &= (BTRFS_BLOCK_GROUP_DATA |
1127                                  BTRFS_BLOCK_GROUP_SYSTEM |
1128                                  BTRFS_BLOCK_GROUP_METADATA);
1129                         btrfs_set_stack_chunk_type(&chunk, type);
1130
1131                         btrfs_set_stack_chunk_num_stripes(&chunk, 1);
1132                         btrfs_set_stack_chunk_sub_stripes(&chunk, 0);
1133                         btrfs_set_stack_stripe_devid(&chunk.stripe, mdres->devid);
1134                         btrfs_set_stack_stripe_offset(&chunk.stripe, key.offset);
1135                         memcpy(chunk.stripe.dev_uuid, mdres->uuid,
1136                                BTRFS_UUID_SIZE);
1137                         write_extent_buffer(eb, &chunk,
1138                                             btrfs_item_ptr_offset(eb, i),
1139                                             sizeof(chunk));
1140                 }
1141                 memcpy(buffer, eb->data, eb->len);
1142                 csum_block(buffer, eb->len);
1143 next:
1144                 size_left -= mdres->leafsize;
1145                 buffer += mdres->leafsize;
1146                 bytenr += mdres->leafsize;
1147         }
1148
1149         return 0;
1150 }
1151
1152 static void write_backup_supers(int fd, u8 *buf)
1153 {
1154         struct stat st;
1155         u64 size;
1156         u64 bytenr;
1157         int i;
1158         int ret;
1159
1160         if (fstat(fd, &st)) {
1161                 fprintf(stderr, "Couldn't stat restore point, won't be able "
1162                         "to write backup supers: %d\n", errno);
1163                 return;
1164         }
1165
1166         size = btrfs_device_size(fd, &st);
1167
1168         for (i = 1; i < BTRFS_SUPER_MIRROR_MAX; i++) {
1169                 bytenr = btrfs_sb_offset(i);
1170                 if (bytenr + 4096 > size)
1171                         break;
1172                 ret = pwrite64(fd, buf, 4096, bytenr);
1173                 if (ret < 4096) {
1174                         if (ret < 0)
1175                                 fprintf(stderr, "Problem writing out backup "
1176                                         "super block %d, err %d\n", i, errno);
1177                         else
1178                                 fprintf(stderr, "Short write writing out "
1179                                         "backup super block\n");
1180                         break;
1181                 }
1182         }
1183 }
1184
1185 static void *restore_worker(void *data)
1186 {
1187         struct mdrestore_struct *mdres = (struct mdrestore_struct *)data;
1188         struct async_work *async;
1189         size_t size;
1190         u8 *buffer;
1191         u8 *outbuf;
1192         int outfd;
1193         int ret;
1194
1195         outfd = fileno(mdres->out);
1196         buffer = malloc(MAX_PENDING_SIZE * 2);
1197         if (!buffer) {
1198                 fprintf(stderr, "Error allocing buffer\n");
1199                 pthread_mutex_lock(&mdres->mutex);
1200                 if (!mdres->error)
1201                         mdres->error = -ENOMEM;
1202                 pthread_mutex_unlock(&mdres->mutex);
1203                 goto out;
1204         }
1205
1206         while (1) {
1207                 int err = 0;
1208
1209                 pthread_mutex_lock(&mdres->mutex);
1210                 while (!mdres->leafsize || list_empty(&mdres->list)) {
1211                         if (mdres->done) {
1212                                 pthread_mutex_unlock(&mdres->mutex);
1213                                 goto out;
1214                         }
1215                         pthread_cond_wait(&mdres->cond, &mdres->mutex);
1216                 }
1217                 async = list_entry(mdres->list.next, struct async_work, list);
1218                 list_del_init(&async->list);
1219                 pthread_mutex_unlock(&mdres->mutex);
1220
1221                 if (mdres->compress_method == COMPRESS_ZLIB) {
1222                         size = MAX_PENDING_SIZE * 2;
1223                         ret = uncompress(buffer, (unsigned long *)&size,
1224                                          async->buffer, async->bufsize);
1225                         if (ret != Z_OK) {
1226                                 fprintf(stderr, "Error decompressing %d\n",
1227                                         ret);
1228                                 err = -EIO;
1229                         }
1230                         outbuf = buffer;
1231                 } else {
1232                         outbuf = async->buffer;
1233                         size = async->bufsize;
1234                 }
1235
1236                 if (async->start == BTRFS_SUPER_INFO_OFFSET) {
1237                         if (mdres->old_restore) {
1238                                 update_super_old(outbuf);
1239                         } else {
1240                                 ret = update_super(outbuf);
1241                                 if (ret)
1242                                         err = ret;
1243                         }
1244                 } else if (!mdres->old_restore) {
1245                         ret = fixup_chunk_tree_block(mdres, async, outbuf, size);
1246                         if (ret)
1247                                 err = ret;
1248                 }
1249
1250                 ret = pwrite64(outfd, outbuf, size, async->start);
1251                 if (ret < size) {
1252                         if (ret < 0) {
1253                                 fprintf(stderr, "Error writing to device %d\n",
1254                                         errno);
1255                                 err = errno;
1256                         } else {
1257                                 fprintf(stderr, "Short write\n");
1258                                 err = -EIO;
1259                         }
1260                 }
1261
1262                 if (async->start == BTRFS_SUPER_INFO_OFFSET)
1263                         write_backup_supers(outfd, outbuf);
1264
1265                 pthread_mutex_lock(&mdres->mutex);
1266                 if (err && !mdres->error)
1267                         mdres->error = err;
1268                 mdres->num_items--;
1269                 pthread_mutex_unlock(&mdres->mutex);
1270
1271                 free(async->buffer);
1272                 free(async);
1273         }
1274 out:
1275         free(buffer);
1276         pthread_exit(NULL);
1277 }
1278
1279 static void mdrestore_destroy(struct mdrestore_struct *mdres)
1280 {
1281         int i;
1282         pthread_mutex_lock(&mdres->mutex);
1283         mdres->done = 1;
1284         pthread_cond_broadcast(&mdres->cond);
1285         pthread_mutex_unlock(&mdres->mutex);
1286
1287         for (i = 0; i < mdres->num_threads; i++)
1288                 pthread_join(mdres->threads[i], NULL);
1289
1290         pthread_cond_destroy(&mdres->cond);
1291         pthread_mutex_destroy(&mdres->mutex);
1292         free(mdres->threads);
1293 }
1294
1295 static int mdrestore_init(struct mdrestore_struct *mdres,
1296                           FILE *in, FILE *out, int old_restore,
1297                           int num_threads)
1298 {
1299         int i, ret = 0;
1300
1301         memset(mdres, 0, sizeof(*mdres));
1302         pthread_cond_init(&mdres->cond, NULL);
1303         pthread_mutex_init(&mdres->mutex, NULL);
1304         INIT_LIST_HEAD(&mdres->list);
1305         mdres->in = in;
1306         mdres->out = out;
1307         mdres->old_restore = old_restore;
1308
1309         if (!num_threads)
1310                 return 0;
1311
1312         mdres->num_threads = num_threads;
1313         mdres->threads = calloc(num_threads, sizeof(pthread_t));
1314         if (!mdres->threads)
1315                 return -ENOMEM;
1316         for (i = 0; i < num_threads; i++) {
1317                 ret = pthread_create(mdres->threads + i, NULL, restore_worker,
1318                                      mdres);
1319                 if (ret)
1320                         break;
1321         }
1322         if (ret)
1323                 mdrestore_destroy(mdres);
1324         return ret;
1325 }
1326
1327 static int fill_mdres_info(struct mdrestore_struct *mdres,
1328                            struct async_work *async)
1329 {
1330         struct btrfs_super_block *super;
1331         u8 *buffer = NULL;
1332         u8 *outbuf;
1333         int ret;
1334
1335         if (mdres->compress_method == COMPRESS_ZLIB) {
1336                 size_t size = MAX_PENDING_SIZE * 2;
1337
1338                 buffer = malloc(MAX_PENDING_SIZE * 2);
1339                 if (!buffer)
1340                         return -ENOMEM;
1341                 ret = uncompress(buffer, (unsigned long *)&size,
1342                                  async->buffer, async->bufsize);
1343                 if (ret != Z_OK) {
1344                         fprintf(stderr, "Error decompressing %d\n", ret);
1345                         free(buffer);
1346                         return -EIO;
1347                 }
1348                 outbuf = buffer;
1349         } else {
1350                 outbuf = async->buffer;
1351         }
1352
1353         super = (struct btrfs_super_block *)outbuf;
1354         mdres->leafsize = btrfs_super_leafsize(super);
1355         memcpy(mdres->fsid, super->fsid, BTRFS_FSID_SIZE);
1356         memcpy(mdres->uuid, super->dev_item.uuid,
1357                        BTRFS_UUID_SIZE);
1358         mdres->devid = le64_to_cpu(super->dev_item.devid);
1359         free(buffer);
1360         return 0;
1361 }
1362
1363 static int add_cluster(struct meta_cluster *cluster,
1364                        struct mdrestore_struct *mdres, u64 *next)
1365 {
1366         struct meta_cluster_item *item;
1367         struct meta_cluster_header *header = &cluster->header;
1368         struct async_work *async;
1369         u64 bytenr;
1370         u32 i, nritems;
1371         int ret;
1372
1373         BUG_ON(mdres->num_items);
1374         mdres->compress_method = header->compress;
1375
1376         bytenr = le64_to_cpu(header->bytenr) + BLOCK_SIZE;
1377         nritems = le32_to_cpu(header->nritems);
1378         for (i = 0; i < nritems; i++) {
1379                 item = &cluster->items[i];
1380                 async = calloc(1, sizeof(*async));
1381                 if (!async) {
1382                         fprintf(stderr, "Error allocating async\n");
1383                         return -ENOMEM;
1384                 }
1385                 async->start = le64_to_cpu(item->bytenr);
1386                 async->bufsize = le32_to_cpu(item->size);
1387                 async->buffer = malloc(async->bufsize);
1388                 if (!async->buffer) {
1389                         fprintf(stderr, "Error allocing async buffer\n");
1390                         free(async);
1391                         return -ENOMEM;
1392                 }
1393                 ret = fread(async->buffer, async->bufsize, 1, mdres->in);
1394                 if (ret != 1) {
1395                         fprintf(stderr, "Error reading buffer %d\n", errno);
1396                         free(async->buffer);
1397                         free(async);
1398                         return -EIO;
1399                 }
1400                 bytenr += async->bufsize;
1401
1402                 pthread_mutex_lock(&mdres->mutex);
1403                 if (async->start == BTRFS_SUPER_INFO_OFFSET) {
1404                         ret = fill_mdres_info(mdres, async);
1405                         if (ret) {
1406                                 fprintf(stderr, "Error setting up restore\n");
1407                                 pthread_mutex_unlock(&mdres->mutex);
1408                                 free(async->buffer);
1409                                 free(async);
1410                                 return ret;
1411                         }
1412                 }
1413                 list_add_tail(&async->list, &mdres->list);
1414                 mdres->num_items++;
1415                 pthread_cond_signal(&mdres->cond);
1416                 pthread_mutex_unlock(&mdres->mutex);
1417         }
1418         if (bytenr & BLOCK_MASK) {
1419                 char buffer[BLOCK_MASK];
1420                 size_t size = BLOCK_SIZE - (bytenr & BLOCK_MASK);
1421
1422                 bytenr += size;
1423                 ret = fread(buffer, size, 1, mdres->in);
1424                 if (ret != 1) {
1425                         fprintf(stderr, "Error reading in buffer %d\n", errno);
1426                         return -EIO;
1427                 }
1428         }
1429         *next = bytenr;
1430         return 0;
1431 }
1432
1433 static int wait_for_worker(struct mdrestore_struct *mdres)
1434 {
1435         int ret = 0;
1436
1437         pthread_mutex_lock(&mdres->mutex);
1438         ret = mdres->error;
1439         while (!ret && mdres->num_items > 0) {
1440                 struct timespec ts = {
1441                         .tv_sec = 0,
1442                         .tv_nsec = 10000000,
1443                 };
1444                 pthread_mutex_unlock(&mdres->mutex);
1445                 nanosleep(&ts, NULL);
1446                 pthread_mutex_lock(&mdres->mutex);
1447                 ret = mdres->error;
1448         }
1449         pthread_mutex_unlock(&mdres->mutex);
1450         return ret;
1451 }
1452
1453 static int restore_metadump(const char *input, FILE *out, int old_restore,
1454                             int num_threads)
1455 {
1456         struct meta_cluster *cluster = NULL;
1457         struct meta_cluster_header *header;
1458         struct mdrestore_struct mdrestore;
1459         u64 bytenr = 0;
1460         FILE *in = NULL;
1461         int ret = 0;
1462
1463         if (!strcmp(input, "-")) {
1464                 in = stdin;
1465         } else {
1466                 in = fopen(input, "r");
1467                 if (!in) {
1468                         perror("unable to open metadump image");
1469                         return 1;
1470                 }
1471         }
1472
1473         cluster = malloc(BLOCK_SIZE);
1474         if (!cluster) {
1475                 fprintf(stderr, "Error allocating cluster\n");
1476                 if (in != stdin)
1477                         fclose(in);
1478                 return -ENOMEM;
1479         }
1480
1481         ret = mdrestore_init(&mdrestore, in, out, old_restore, num_threads);
1482         if (ret) {
1483                 fprintf(stderr, "Error initing mdrestore %d\n", ret);
1484                 if (in != stdin)
1485                         fclose(in);
1486                 free(cluster);
1487                 return ret;
1488         }
1489
1490         while (1) {
1491                 ret = fread(cluster, BLOCK_SIZE, 1, in);
1492                 if (!ret)
1493                         break;
1494
1495                 header = &cluster->header;
1496                 if (le64_to_cpu(header->magic) != HEADER_MAGIC ||
1497                     le64_to_cpu(header->bytenr) != bytenr) {
1498                         fprintf(stderr, "bad header in metadump image\n");
1499                         ret = -EIO;
1500                         break;
1501                 }
1502                 ret = add_cluster(cluster, &mdrestore, &bytenr);
1503                 if (ret) {
1504                         fprintf(stderr, "Error adding cluster\n");
1505                         break;
1506                 }
1507
1508                 ret = wait_for_worker(&mdrestore);
1509                 if (ret) {
1510                         fprintf(stderr, "One of the threads errored out %d\n",
1511                                 ret);
1512                         break;
1513                 }
1514         }
1515
1516         mdrestore_destroy(&mdrestore);
1517         free(cluster);
1518         if (in != stdin)
1519                 fclose(in);
1520         return ret;
1521 }
1522
1523 static void print_usage(void)
1524 {
1525         fprintf(stderr, "usage: btrfs-image [options] source target\n");
1526         fprintf(stderr, "\t-r      \trestore metadump image\n");
1527         fprintf(stderr, "\t-c value\tcompression level (0 ~ 9)\n");
1528         fprintf(stderr, "\t-t value\tnumber of threads (1 ~ 32)\n");
1529         fprintf(stderr, "\t-o      \tdon't mess with the chunk tree when restoring\n");
1530         fprintf(stderr, "\t-w      \twalk all trees instead of using extent tree, do this if your extent tree is broken\n");
1531         exit(1);
1532 }
1533
1534 int main(int argc, char *argv[])
1535 {
1536         char *source;
1537         char *target;
1538         int num_threads = 0;
1539         int compress_level = 0;
1540         int create = 1;
1541         int old_restore = 0;
1542         int walk_trees = 0;
1543         int ret;
1544         FILE *out;
1545
1546         while (1) {
1547                 int c = getopt(argc, argv, "rc:t:ow");
1548                 if (c < 0)
1549                         break;
1550                 switch (c) {
1551                 case 'r':
1552                         create = 0;
1553                         break;
1554                 case 't':
1555                         num_threads = atoi(optarg);
1556                         if (num_threads <= 0 || num_threads > 32)
1557                                 print_usage();
1558                         break;
1559                 case 'c':
1560                         compress_level = atoi(optarg);
1561                         if (compress_level < 0 || compress_level > 9)
1562                                 print_usage();
1563                         break;
1564                 case 'o':
1565                         old_restore = 1;
1566                         break;
1567                 case 'w':
1568                         walk_trees = 1;
1569                         break;
1570                 default:
1571                         print_usage();
1572                 }
1573         }
1574
1575         if (old_restore && create)
1576                 print_usage();
1577
1578         argc = argc - optind;
1579         if (argc != 2)
1580                 print_usage();
1581         source = argv[optind];
1582         target = argv[optind + 1];
1583
1584         if (create && !strcmp(target, "-")) {
1585                 out = stdout;
1586         } else {
1587                 out = fopen(target, "w+");
1588                 if (!out) {
1589                         perror("unable to create target file");
1590                         exit(1);
1591                 }
1592         }
1593
1594         if (num_threads == 0 && compress_level > 0) {
1595                 num_threads = sysconf(_SC_NPROCESSORS_ONLN);
1596                 if (num_threads <= 0)
1597                         num_threads = 1;
1598         }
1599
1600         if (create)
1601                 ret = create_metadump(source, out, num_threads,
1602                                       compress_level, walk_trees);
1603         else
1604                 ret = restore_metadump(source, out, old_restore, 1);
1605
1606         if (out == stdout)
1607                 fflush(out);
1608         else
1609                 fclose(out);
1610
1611         return ret;
1612 }