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                         eb = read_tree_block(md->root, start, blocksize, 0);
 510                         if (!eb) {
 511                                 free(async->buffer);
 512                                 free(async);
 513                                 fprintf(stderr,
 514                                         "Error reading metadata block\n");
 515                                 return -EIO;
 516                         }
 517                         copy_buffer(async->buffer + offset, eb);
 518                         free_extent_buffer(eb);
 519                         start += blocksize;
 520                         offset += blocksize;
 521                         size -= blocksize;
 522                 }
 523
 524                 md->pending_start = (u64)-1;
 525                 md->pending_size = 0;
 526         } else if (!done) {
 527                 return 0;
 528         }
 529
 530         pthread_mutex_lock(&md->mutex);
 531         if (async) {
 532                 list_add_tail(&async->ordered, &md->ordered);
 533                 md->num_items++;
 534                 if (md->compress_level > 0) {
 535                         list_add_tail(&async->list, &md->list);
 536                         pthread_cond_signal(&md->cond);
 537                 } else {
 538                         md->num_ready++;
 539                 }
 540         }
 541         if (md->num_items >= ITEMS_PER_CLUSTER || done) {
 542                 ret = write_buffers(md, &start);
 543                 if (ret)
 544                         fprintf(stderr, "Error writing buffers %d\n",
 545                                 errno);
 546                 else
 547                         meta_cluster_init(md, start);
 548         }
 549         pthread_mutex_unlock(&md->mutex);
 550         return ret;
 551 }
 552
 553 static int add_extent(u64 start, u64 size, struct metadump_struct *md,
 554                       int data)
 555 {
 556         int ret;
 557         if (md->data != data ||
 558             md->pending_size + size > MAX_PENDING_SIZE ||
 559             md->pending_start + md->pending_size != start) {
 560                 ret = flush_pending(md, 0);
 561                 if (ret)
 562                         return ret;
 563                 md->pending_start = start;
 564         }
 565         readahead_tree_block(md->root, start, size, 0);
 566         md->pending_size += size;
 567         md->data = data;
 568         return 0;
 569 }
 570
 571 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
 572 static int is_tree_block(struct btrfs_root *extent_root,
 573                          struct btrfs_path *path, u64 bytenr)
 574 {
 575         struct extent_buffer *leaf;
 576         struct btrfs_key key;
 577         u64 ref_objectid;
 578         int ret;
 579
 580         leaf = path->nodes[0];
 581         while (1) {
 582                 struct btrfs_extent_ref_v0 *ref_item;
 583                 path->slots[0]++;
 584                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
 585                         ret = btrfs_next_leaf(extent_root, path);
 586                         if (ret < 0)
 587                                 return ret;
 588                         if (ret > 0)
 589                                 break;
 590                         leaf = path->nodes[0];
 591                 }
 592                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 593                 if (key.objectid != bytenr)
 594                         break;
 595                 if (key.type != BTRFS_EXTENT_REF_V0_KEY)
 596                         continue;
 597                 ref_item = btrfs_item_ptr(leaf, path->slots[0],
 598                                           struct btrfs_extent_ref_v0);
 599                 ref_objectid = btrfs_ref_objectid_v0(leaf, ref_item);
 600                 if (ref_objectid < BTRFS_FIRST_FREE_OBJECTID)
 601                         return 1;
 602                 break;
 603         }
 604         return 0;
 605 }
 606 #endif
 607
 608 static int copy_tree_blocks(struct btrfs_root *root, struct extent_buffer *eb,
 609                             struct metadump_struct *metadump, int root_tree)
 610 {
 611         struct extent_buffer *tmp;
 612         struct btrfs_root_item *ri;
 613         struct btrfs_key key;
 614         u64 bytenr;
 615         int level;
 616         int nritems = 0;
 617         int i = 0;
 618         int ret;
 619
 620         ret = add_extent(btrfs_header_bytenr(eb), root->leafsize, metadump, 0);
 621         if (ret) {
 622                 fprintf(stderr, "Error adding metadata block\n");
 623                 return ret;
 624         }
 625
 626         if (btrfs_header_level(eb) == 0 && !root_tree)
 627                 return 0;
 628
 629         level = btrfs_header_level(eb);
 630         nritems = btrfs_header_nritems(eb);
 631         for (i = 0; i < nritems; i++) {
 632                 if (level == 0) {
 633                         btrfs_item_key_to_cpu(eb, &key, i);
 634                         if (key.type != BTRFS_ROOT_ITEM_KEY)
 635                                 continue;
 636                         ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
 637                         bytenr = btrfs_disk_root_bytenr(eb, ri);
 638                         tmp = read_tree_block(root, bytenr, root->leafsize, 0);
 639                         if (!tmp) {
 640                                 fprintf(stderr,
 641                                         "Error reading log root block\n");
 642                                 return -EIO;
 643                         }
 644                         ret = copy_tree_blocks(root, tmp, metadump, 0);
 645                         free_extent_buffer(tmp);
 646                         if (ret)
 647                                 return ret;
 648                 } else {
 649                         bytenr = btrfs_node_blockptr(eb, i);
 650                         tmp = read_tree_block(root, bytenr, root->leafsize, 0);
 651                         if (!tmp) {
 652                                 fprintf(stderr, "Error reading log block\n");
 653                                 return -EIO;
 654                         }
 655                         ret = copy_tree_blocks(root, tmp, metadump, root_tree);
 656                         free_extent_buffer(tmp);
 657                         if (ret)
 658                                 return ret;
 659                 }
 660         }
 661
 662         return 0;
 663 }
 664
 665 static int copy_log_trees(struct btrfs_root *root,
 666                           struct metadump_struct *metadump,
 667                           struct btrfs_path *path)
 668 {
 669         u64 blocknr = btrfs_super_log_root(root->fs_info->super_copy);
 670
 671         if (blocknr == 0)
 672                 return 0;
 673
 674         if (!root->fs_info->log_root_tree ||
 675             !root->fs_info->log_root_tree->node) {
 676                 fprintf(stderr, "Error copying tree log, it wasn't setup\n");
 677                 return -EIO;
 678         }
 679
 680         return copy_tree_blocks(root, root->fs_info->log_root_tree->node,
 681                                 metadump, 1);
 682 }
 683
 684 static int copy_space_cache(struct btrfs_root *root,
 685                             struct metadump_struct *metadump,
 686                             struct btrfs_path *path)
 687 {
 688         struct extent_buffer *leaf;
 689         struct btrfs_file_extent_item *fi;
 690         struct btrfs_key key;
 691         u64 bytenr, num_bytes;
 692         int ret;
 693
 694         root = root->fs_info->tree_root;
 695
 696         key.objectid = 0;
 697         key.type = BTRFS_EXTENT_DATA_KEY;
 698         key.offset = 0;
 699
 700         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 701         if (ret < 0) {
 702                 fprintf(stderr, "Error searching for free space inode %d\n",
 703                         ret);
 704                 return ret;
 705         }
 706
 707         while (1) {
 708                 leaf = path->nodes[0];
 709                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
 710                         ret = btrfs_next_leaf(root, path);
 711                         if (ret < 0) {
 712                                 fprintf(stderr, "Error going to next leaf "
 713                                         "%d\n", ret);
 714                                 return ret;
 715                         }
 716                         if (ret > 0)
 717                                 break;
 718                         leaf = path->nodes[0];
 719                 }
 720
 721                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 722                 if (key.type != BTRFS_EXTENT_DATA_KEY) {
 723                         path->slots[0]++;
 724                         continue;
 725                 }
 726
 727                 fi = btrfs_item_ptr(leaf, path->slots[0],
 728                                     struct btrfs_file_extent_item);
 729                 if (btrfs_file_extent_type(leaf, fi) !=
 730                     BTRFS_FILE_EXTENT_REG) {
 731                         path->slots[0]++;
 732                         continue;
 733                 }
 734
 735                 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
 736                 num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
 737                 ret = add_extent(bytenr, num_bytes, metadump, 1);
 738                 if (ret) {
 739                         fprintf(stderr, "Error adding space cache blocks %d\n",
 740                                 ret);
 741                         btrfs_release_path(root, path);
 742                         return ret;
 743                 }
 744                 path->slots[0]++;
 745         }
 746
 747         return 0;
 748 }
 749
 750 static int copy_from_extent_tree(struct metadump_struct *metadump,
 751                                  struct btrfs_path *path)
 752 {
 753         struct btrfs_root *extent_root;
 754         struct extent_buffer *leaf;
 755         struct btrfs_extent_item *ei;
 756         struct btrfs_key key;
 757         u64 bytenr;
 758         u64 num_bytes;
 759         int ret;
 760
 761         extent_root = metadump->root->fs_info->extent_root;
 762         bytenr = BTRFS_SUPER_INFO_OFFSET + 4096;
 763         key.objectid = bytenr;
 764         key.type = BTRFS_EXTENT_ITEM_KEY;
 765         key.offset = 0;
 766
 767         ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
 768         if (ret < 0) {
 769                 fprintf(stderr, "Error searching extent root %d\n", ret);
 770                 return ret;
 771         }
 772         ret = 0;
 773
 774         while (1) {
 775                 leaf = path->nodes[0];
 776                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
 777                         ret = btrfs_next_leaf(extent_root, path);
 778                         if (ret < 0) {
 779                                 fprintf(stderr, "Error going to next leaf %d"
 780                                         "\n", ret);
 781                                 break;
 782                         }
 783                         if (ret > 0) {
 784                                 ret = 0;
 785                                 break;
 786                         }
 787                         leaf = path->nodes[0];
 788                 }
 789
 790                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 791                 if (key.objectid < bytenr ||
 792                     (key.type != BTRFS_EXTENT_ITEM_KEY &&
 793                      key.type != BTRFS_METADATA_ITEM_KEY)) {
 794                         path->slots[0]++;
 795                         continue;
 796                 }
 797
 798                 bytenr = key.objectid;
 799                 if (key.type == BTRFS_METADATA_ITEM_KEY)
 800                         num_bytes = key.offset;
 801                 else
 802                         num_bytes = extent_root->leafsize;
 803
 804                 if (btrfs_item_size_nr(leaf, path->slots[0]) > sizeof(*ei)) {
 805                         ei = btrfs_item_ptr(leaf, path->slots[0],
 806                                             struct btrfs_extent_item);
 807                         if (btrfs_extent_flags(leaf, ei) &
 808                             BTRFS_EXTENT_FLAG_TREE_BLOCK) {
 809                                 ret = add_extent(bytenr, num_bytes, metadump,
 810                                                  0);
 811                                 if (ret) {
 812                                         fprintf(stderr, "Error adding block "
 813                                                 "%d\n", ret);
 814                                         break;
 815                                 }
 816                         }
 817                 } else {
 818 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
 819                         ret = is_tree_block(extent_root, path, bytenr);
 820                         if (ret < 0) {
 821                                 fprintf(stderr, "Error checking tree block "
 822                                         "%d\n", ret);
 823                                 break;
 824                         }
 825
 826                         if (ret) {
 827                                 ret = add_extent(bytenr, num_bytes, metadump,
 828                                                  0);
 829                                 if (ret) {
 830                                         fprintf(stderr, "Error adding block "
 831                                                 "%d\n", ret);
 832                                         break;
 833                                 }
 834                         }
 835                         ret = 0;
 836 #else
 837                         fprintf(stderr, "Either extent tree corruption or "
 838                                 "you haven't built with V0 support\n");
 839                         ret = -EIO;
 840                         break;
 841 #endif
 842                 }
 843                 bytenr += num_bytes;
 844         }
 845
 846         btrfs_release_path(extent_root, path);
 847
 848         return ret;
 849 }
 850
 851 static int create_metadump(const char *input, FILE *out, int num_threads,
 852                            int compress_level, int walk_trees)
 853 {
 854         struct btrfs_root *root;
 855         struct btrfs_path *path = NULL;
 856         struct metadump_struct metadump;
 857         int ret;
 858         int err = 0;
 859
 860         root = open_ctree(input, 0, 0);
 861         if (!root) {
 862                 fprintf(stderr, "Open ctree failed\n");
 863                 return -EIO;
 864         }
 865
 866         BUG_ON(root->nodesize != root->leafsize);
 867
 868         ret = metadump_init(&metadump, root, out, num_threads,
 869                             compress_level);
 870         if (ret) {
 871                 fprintf(stderr, "Error initing metadump %d\n", ret);
 872                 close_ctree(root);
 873                 return ret;
 874         }
 875
 876         ret = add_extent(BTRFS_SUPER_INFO_OFFSET, 4096, &metadump, 0);
 877         if (ret) {
 878                 fprintf(stderr, "Error adding metadata %d\n", ret);
 879                 err = ret;
 880                 goto out;
 881         }
 882
 883         path = btrfs_alloc_path();
 884         if (!path) {
 885                 fprintf(stderr, "Out of memory allocing path\n");
 886                 err = -ENOMEM;
 887                 goto out;
 888         }
 889
 890         if (walk_trees) {
 891                 ret = copy_tree_blocks(root, root->fs_info->chunk_root->node,
 892                                        &metadump, 1);
 893                 if (ret) {
 894                         err = ret;
 895                         goto out;
 896                 }
 897
 898                 ret = copy_tree_blocks(root, root->fs_info->tree_root->node,
 899                                        &metadump, 1);
 900                 if (ret) {
 901                         err = ret;
 902                         goto out;
 903                 }
 904         } else {
 905                 ret = copy_from_extent_tree(&metadump, path);
 906                 if (ret) {
 907                         err = ret;
 908                         goto out;
 909                 }
 910         }
 911
 912         ret = copy_log_trees(root, &metadump, path);
 913         if (ret) {
 914                 err = ret;
 915                 goto out;
 916         }
 917
 918         ret = copy_space_cache(root, &metadump, path);
 919 out:
 920         ret = flush_pending(&metadump, 1);
 921         if (ret) {
 922                 if (!err)
 923                         err = ret;
 924                 fprintf(stderr, "Error flushing pending %d\n", ret);
 925         }
 926
 927         metadump_destroy(&metadump);
 928
 929         btrfs_free_path(path);
 930         ret = close_ctree(root);
 931         return err ? err : ret;
 932 }
 933
 934 static void update_super_old(u8 *buffer)
 935 {
 936         struct btrfs_super_block *super = (struct btrfs_super_block *)buffer;
 937         struct btrfs_chunk *chunk;
 938         struct btrfs_disk_key *key;
 939         u32 sectorsize = btrfs_super_sectorsize(super);
 940         u64 flags = btrfs_super_flags(super);
 941
 942         flags |= BTRFS_SUPER_FLAG_METADUMP;
 943         btrfs_set_super_flags(super, flags);
 944
 945         key = (struct btrfs_disk_key *)(super->sys_chunk_array);
 946         chunk = (struct btrfs_chunk *)(super->sys_chunk_array +
 947                                        sizeof(struct btrfs_disk_key));
 948
 949         btrfs_set_disk_key_objectid(key, BTRFS_FIRST_CHUNK_TREE_OBJECTID);
 950         btrfs_set_disk_key_type(key, BTRFS_CHUNK_ITEM_KEY);
 951         btrfs_set_disk_key_offset(key, 0);
 952
 953         btrfs_set_stack_chunk_length(chunk, (u64)-1);
 954         btrfs_set_stack_chunk_owner(chunk, BTRFS_EXTENT_TREE_OBJECTID);
 955         btrfs_set_stack_chunk_stripe_len(chunk, 64 * 1024);
 956         btrfs_set_stack_chunk_type(chunk, BTRFS_BLOCK_GROUP_SYSTEM);
 957         btrfs_set_stack_chunk_io_align(chunk, sectorsize);
 958         btrfs_set_stack_chunk_io_width(chunk, sectorsize);
 959         btrfs_set_stack_chunk_sector_size(chunk, sectorsize);
 960         btrfs_set_stack_chunk_num_stripes(chunk, 1);
 961         btrfs_set_stack_chunk_sub_stripes(chunk, 0);
 962         chunk->stripe.devid = super->dev_item.devid;
 963         chunk->stripe.offset = cpu_to_le64(0);
 964         memcpy(chunk->stripe.dev_uuid, super->dev_item.uuid, BTRFS_UUID_SIZE);
 965         btrfs_set_super_sys_array_size(super, sizeof(*key) + sizeof(*chunk));
 966         csum_block(buffer, 4096);
 967 }
 968
 969 static int update_super(u8 *buffer)
 970 {
 971         struct btrfs_super_block *super = (struct btrfs_super_block *)buffer;
 972         struct btrfs_chunk *chunk;
 973         struct btrfs_disk_key *disk_key;
 974         struct btrfs_key key;
 975         u32 new_array_size = 0;
 976         u32 array_size;
 977         u32 cur = 0;
 978         u32 new_cur = 0;
 979         u8 *ptr, *write_ptr;
 980         int old_num_stripes;
 981
 982         write_ptr = ptr = super->sys_chunk_array;
 983         array_size = btrfs_super_sys_array_size(super);
 984
 985         while (cur < array_size) {
 986                 disk_key = (struct btrfs_disk_key *)ptr;
 987                 btrfs_disk_key_to_cpu(&key, disk_key);
 988
 989                 new_array_size += sizeof(*disk_key);
 990                 memmove(write_ptr, ptr, sizeof(*disk_key));
 991
 992                 write_ptr += sizeof(*disk_key);
 993                 ptr += sizeof(*disk_key);
 994                 cur += sizeof(*disk_key);
 995                 new_cur += sizeof(*disk_key);
 996
 997                 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
 998                         chunk = (struct btrfs_chunk *)ptr;
 999                         old_num_stripes = btrfs_stack_chunk_num_stripes(chunk);
1000                         chunk = (struct btrfs_chunk *)write_ptr;
1001
1002                         memmove(write_ptr, ptr, sizeof(*chunk));
1003                         btrfs_set_stack_chunk_num_stripes(chunk, 1);
1004                         btrfs_set_stack_chunk_sub_stripes(chunk, 0);
1005                         btrfs_set_stack_chunk_type(chunk,
1006                                                    BTRFS_BLOCK_GROUP_SYSTEM);
1007                         chunk->stripe.devid = super->dev_item.devid;
1008                         chunk->stripe.offset = cpu_to_le64(key.offset);
1009                         memcpy(chunk->stripe.dev_uuid, super->dev_item.uuid,
1010                                BTRFS_UUID_SIZE);
1011                         new_array_size += sizeof(*chunk);
1012                         new_cur += sizeof(*chunk);
1013                 } else {
1014                         fprintf(stderr, "Bogus key in the sys chunk array "
1015                                 "%d\n", key.type);
1016                         return -EIO;
1017                 }
1018                 write_ptr += sizeof(*chunk);
1019                 ptr += btrfs_chunk_item_size(old_num_stripes);
1020                 cur += btrfs_chunk_item_size(old_num_stripes);
1021         }
1022
1023         btrfs_set_super_sys_array_size(super, new_array_size);
1024         csum_block(buffer, 4096);
1025
1026         return 0;
1027 }
1028
1029 static struct extent_buffer *alloc_dummy_eb(u64 bytenr, u32 size)
1030 {
1031         struct extent_buffer *eb;
1032
1033         eb = malloc(sizeof(struct extent_buffer) + size);
1034         if (!eb)
1035                 return NULL;
1036         memset(eb, 0, sizeof(struct extent_buffer) + size);
1037
1038         eb->start = bytenr;
1039         eb->len = size;
1040         return eb;
1041 }
1042
1043 static void truncate_item(struct extent_buffer *eb, int slot, u32 new_size)
1044 {
1045         struct btrfs_item *item;
1046         u32 nritems;
1047         u32 old_size;
1048         u32 old_data_start;
1049         u32 size_diff;
1050         u32 data_end;
1051         int i;
1052
1053         old_size = btrfs_item_size_nr(eb, slot);
1054         if (old_size == new_size)
1055                 return;
1056
1057         nritems = btrfs_header_nritems(eb);
1058         data_end = btrfs_item_offset_nr(eb, nritems - 1);
1059
1060         old_data_start = btrfs_item_offset_nr(eb, slot);
1061         size_diff = old_size - new_size;
1062
1063         for (i = slot; i < nritems; i++) {
1064                 u32 ioff;
1065                 item = btrfs_item_nr(eb, i);
1066                 ioff = btrfs_item_offset(eb, item);
1067                 btrfs_set_item_offset(eb, item, ioff + size_diff);
1068         }
1069
1070         memmove_extent_buffer(eb, btrfs_leaf_data(eb) + data_end + size_diff,
1071                               btrfs_leaf_data(eb) + data_end,
1072                               old_data_start + new_size - data_end);
1073         item = btrfs_item_nr(eb, slot);
1074         btrfs_set_item_size(eb, item, new_size);
1075 }
1076
1077 static int fixup_chunk_tree_block(struct mdrestore_struct *mdres,
1078                                   struct async_work *async, u8 *buffer,
1079                                   size_t size)
1080 {
1081         struct extent_buffer *eb;
1082         size_t size_left = size;
1083         u64 bytenr = async->start;
1084         int i;
1085
1086         if (size_left % mdres->leafsize)
1087                 return 0;
1088
1089         eb = alloc_dummy_eb(bytenr, mdres->leafsize);
1090         if (!eb)
1091                 return -ENOMEM;
1092
1093         while (size_left) {
1094                 eb->start = bytenr;
1095                 memcpy(eb->data, buffer, mdres->leafsize);
1096
1097                 if (btrfs_header_bytenr(eb) != bytenr)
1098                         break;
1099                 if (memcmp(mdres->fsid,
1100                            eb->data + offsetof(struct btrfs_header, fsid),
1101                            BTRFS_FSID_SIZE))
1102                         break;
1103
1104                 if (btrfs_header_owner(eb) != BTRFS_CHUNK_TREE_OBJECTID)
1105                         goto next;
1106
1107                 if (btrfs_header_level(eb) != 0)
1108                         goto next;
1109
1110                 for (i = 0; i < btrfs_header_nritems(eb); i++) {
1111                         struct btrfs_chunk chunk;
1112                         struct btrfs_key key;
1113                         u64 type;
1114
1115                         btrfs_item_key_to_cpu(eb, &key, i);
1116                         if (key.type != BTRFS_CHUNK_ITEM_KEY)
1117                                 continue;
1118                         truncate_item(eb, i, sizeof(chunk));
1119                         read_extent_buffer(eb, &chunk,
1120                                            btrfs_item_ptr_offset(eb, i),
1121                                            sizeof(chunk));
1122
1123                         /* Zero out the RAID profile */
1124                         type = btrfs_stack_chunk_type(&chunk);
1125                         type &= (BTRFS_BLOCK_GROUP_DATA |
1126                                  BTRFS_BLOCK_GROUP_SYSTEM |
1127                                  BTRFS_BLOCK_GROUP_METADATA);
1128                         btrfs_set_stack_chunk_type(&chunk, type);
1129
1130                         btrfs_set_stack_chunk_num_stripes(&chunk, 1);
1131                         btrfs_set_stack_chunk_sub_stripes(&chunk, 0);
1132                         btrfs_set_stack_stripe_devid(&chunk.stripe, mdres->devid);
1133                         btrfs_set_stack_stripe_offset(&chunk.stripe, key.offset);
1134                         memcpy(chunk.stripe.dev_uuid, mdres->uuid,
1135                                BTRFS_UUID_SIZE);
1136                         write_extent_buffer(eb, &chunk,
1137                                             btrfs_item_ptr_offset(eb, i),
1138                                             sizeof(chunk));
1139                 }
1140                 memcpy(buffer, eb->data, eb->len);
1141                 csum_block(buffer, eb->len);
1142 next:
1143                 size_left -= mdres->leafsize;
1144                 buffer += mdres->leafsize;
1145                 bytenr += mdres->leafsize;
1146         }
1147
1148         return 0;
1149 }
1150
1151 static void write_backup_supers(int fd, u8 *buf)
1152 {
1153         struct stat st;
1154         u64 size;
1155         u64 bytenr;
1156         int i;
1157         int ret;
1158
1159         if (fstat(fd, &st)) {
1160                 fprintf(stderr, "Couldn't stat restore point, won't be able "
1161                         "to write backup supers: %d\n", errno);
1162                 return;
1163         }
1164
1165         size = btrfs_device_size(fd, &st);
1166
1167         for (i = 1; i < BTRFS_SUPER_MIRROR_MAX; i++) {
1168                 bytenr = btrfs_sb_offset(i);
1169                 if (bytenr + 4096 > size)
1170                         break;
1171                 ret = pwrite64(fd, buf, 4096, bytenr);
1172                 if (ret < 4096) {
1173                         if (ret < 0)
1174                                 fprintf(stderr, "Problem writing out backup "
1175                                         "super block %d, err %d\n", i, errno);
1176                         else
1177                                 fprintf(stderr, "Short write writing out "
1178                                         "backup super block\n");
1179                         break;
1180                 }
1181         }
1182 }
1183
1184 static void *restore_worker(void *data)
1185 {
1186         struct mdrestore_struct *mdres = (struct mdrestore_struct *)data;
1187         struct async_work *async;
1188         size_t size;
1189         u8 *buffer;
1190         u8 *outbuf;
1191         int outfd;
1192         int ret;
1193
1194         outfd = fileno(mdres->out);
1195         buffer = malloc(MAX_PENDING_SIZE * 2);
1196         if (!buffer) {
1197                 fprintf(stderr, "Error allocing buffer\n");
1198                 pthread_mutex_lock(&mdres->mutex);
1199                 if (!mdres->error)
1200                         mdres->error = -ENOMEM;
1201                 pthread_mutex_unlock(&mdres->mutex);
1202                 goto out;
1203         }
1204
1205         while (1) {
1206                 int err = 0;
1207
1208                 pthread_mutex_lock(&mdres->mutex);
1209                 while (!mdres->leafsize || list_empty(&mdres->list)) {
1210                         if (mdres->done) {
1211                                 pthread_mutex_unlock(&mdres->mutex);
1212                                 goto out;
1213                         }
1214                         pthread_cond_wait(&mdres->cond, &mdres->mutex);
1215                 }
1216                 async = list_entry(mdres->list.next, struct async_work, list);
1217                 list_del_init(&async->list);
1218                 pthread_mutex_unlock(&mdres->mutex);
1219
1220                 if (mdres->compress_method == COMPRESS_ZLIB) {
1221                         size = MAX_PENDING_SIZE * 2;
1222                         ret = uncompress(buffer, (unsigned long *)&size,
1223                                          async->buffer, async->bufsize);
1224                         if (ret != Z_OK) {
1225                                 fprintf(stderr, "Error decompressing %d\n",
1226                                         ret);
1227                                 err = -EIO;
1228                         }
1229                         outbuf = buffer;
1230                 } else {
1231                         outbuf = async->buffer;
1232                         size = async->bufsize;
1233                 }
1234
1235                 if (async->start == BTRFS_SUPER_INFO_OFFSET) {
1236                         if (mdres->old_restore) {
1237                                 update_super_old(outbuf);
1238                         } else {
1239                                 ret = update_super(outbuf);
1240                                 if (ret)
1241                                         err = ret;
1242                         }
1243                 } else if (!mdres->old_restore) {
1244                         ret = fixup_chunk_tree_block(mdres, async, outbuf, size);
1245                         if (ret)
1246                                 err = ret;
1247                 }
1248
1249                 ret = pwrite64(outfd, outbuf, size, async->start);
1250                 if (ret < size) {
1251                         if (ret < 0) {
1252                                 fprintf(stderr, "Error writing to device %d\n",
1253                                         errno);
1254                                 err = errno;
1255                         } else {
1256                                 fprintf(stderr, "Short write\n");
1257                                 err = -EIO;
1258                         }
1259                 }
1260
1261                 if (async->start == BTRFS_SUPER_INFO_OFFSET)
1262                         write_backup_supers(outfd, outbuf);
1263
1264                 pthread_mutex_lock(&mdres->mutex);
1265                 if (err && !mdres->error)
1266                         mdres->error = err;
1267                 mdres->num_items--;
1268                 pthread_mutex_unlock(&mdres->mutex);
1269
1270                 free(async->buffer);
1271                 free(async);
1272         }
1273 out:
1274         free(buffer);
1275         pthread_exit(NULL);
1276 }
1277
1278 static void mdrestore_destroy(struct mdrestore_struct *mdres)
1279 {
1280         int i;
1281         pthread_mutex_lock(&mdres->mutex);
1282         mdres->done = 1;
1283         pthread_cond_broadcast(&mdres->cond);
1284         pthread_mutex_unlock(&mdres->mutex);
1285
1286         for (i = 0; i < mdres->num_threads; i++)
1287                 pthread_join(mdres->threads[i], NULL);
1288
1289         pthread_cond_destroy(&mdres->cond);
1290         pthread_mutex_destroy(&mdres->mutex);
1291         free(mdres->threads);
1292 }
1293
1294 static int mdrestore_init(struct mdrestore_struct *mdres,
1295                           FILE *in, FILE *out, int old_restore,
1296                           int num_threads)
1297 {
1298         int i, ret = 0;
1299
1300         memset(mdres, 0, sizeof(*mdres));
1301         pthread_cond_init(&mdres->cond, NULL);
1302         pthread_mutex_init(&mdres->mutex, NULL);
1303         INIT_LIST_HEAD(&mdres->list);
1304         mdres->in = in;
1305         mdres->out = out;
1306         mdres->old_restore = old_restore;
1307
1308         if (!num_threads)
1309                 return 0;
1310
1311         mdres->num_threads = num_threads;
1312         mdres->threads = calloc(num_threads, sizeof(pthread_t));
1313         if (!mdres->threads)
1314                 return -ENOMEM;
1315         for (i = 0; i < num_threads; i++) {
1316                 ret = pthread_create(mdres->threads + i, NULL, restore_worker,
1317                                      mdres);
1318                 if (ret)
1319                         break;
1320         }
1321         if (ret)
1322                 mdrestore_destroy(mdres);
1323         return ret;
1324 }
1325
1326 static int fill_mdres_info(struct mdrestore_struct *mdres,
1327                            struct async_work *async)
1328 {
1329         struct btrfs_super_block *super;
1330         u8 *buffer = NULL;
1331         u8 *outbuf;
1332         int ret;
1333
1334         if (mdres->compress_method == COMPRESS_ZLIB) {
1335                 size_t size = MAX_PENDING_SIZE * 2;
1336
1337                 buffer = malloc(MAX_PENDING_SIZE * 2);
1338                 if (!buffer)
1339                         return -ENOMEM;
1340                 ret = uncompress(buffer, (unsigned long *)&size,
1341                                  async->buffer, async->bufsize);
1342                 if (ret != Z_OK) {
1343                         fprintf(stderr, "Error decompressing %d\n", ret);
1344                         free(buffer);
1345                         return -EIO;
1346                 }
1347                 outbuf = buffer;
1348         } else {
1349                 outbuf = async->buffer;
1350         }
1351
1352         super = (struct btrfs_super_block *)outbuf;
1353         mdres->leafsize = btrfs_super_leafsize(super);
1354         memcpy(mdres->fsid, super->fsid, BTRFS_FSID_SIZE);
1355         memcpy(mdres->uuid, super->dev_item.uuid,
1356                        BTRFS_UUID_SIZE);
1357         mdres->devid = le64_to_cpu(super->dev_item.devid);
1358         free(buffer);
1359         return 0;
1360 }
1361
1362 static int add_cluster(struct meta_cluster *cluster,
1363                        struct mdrestore_struct *mdres, u64 *next)
1364 {
1365         struct meta_cluster_item *item;
1366         struct meta_cluster_header *header = &cluster->header;
1367         struct async_work *async;
1368         u64 bytenr;
1369         u32 i, nritems;
1370         int ret;
1371
1372         BUG_ON(mdres->num_items);
1373         mdres->compress_method = header->compress;
1374
1375         bytenr = le64_to_cpu(header->bytenr) + BLOCK_SIZE;
1376         nritems = le32_to_cpu(header->nritems);
1377         for (i = 0; i < nritems; i++) {
1378                 item = &cluster->items[i];
1379                 async = calloc(1, sizeof(*async));
1380                 if (!async) {
1381                         fprintf(stderr, "Error allocating async\n");
1382                         return -ENOMEM;
1383                 }
1384                 async->start = le64_to_cpu(item->bytenr);
1385                 async->bufsize = le32_to_cpu(item->size);
1386                 async->buffer = malloc(async->bufsize);
1387                 if (!async->buffer) {
1388                         fprintf(stderr, "Error allocing async buffer\n");
1389                         free(async);
1390                         return -ENOMEM;
1391                 }
1392                 ret = fread(async->buffer, async->bufsize, 1, mdres->in);
1393                 if (ret != 1) {
1394                         fprintf(stderr, "Error reading buffer %d\n", errno);
1395                         free(async->buffer);
1396                         free(async);
1397                         return -EIO;
1398                 }
1399                 bytenr += async->bufsize;
1400
1401                 pthread_mutex_lock(&mdres->mutex);
1402                 if (async->start == BTRFS_SUPER_INFO_OFFSET) {
1403                         ret = fill_mdres_info(mdres, async);
1404                         if (ret) {
1405                                 fprintf(stderr, "Error setting up restore\n");
1406                                 pthread_mutex_unlock(&mdres->mutex);
1407                                 free(async->buffer);
1408                                 free(async);
1409                                 return ret;
1410                         }
1411                 }
1412                 list_add_tail(&async->list, &mdres->list);
1413                 mdres->num_items++;
1414                 pthread_cond_signal(&mdres->cond);
1415                 pthread_mutex_unlock(&mdres->mutex);
1416         }
1417         if (bytenr & BLOCK_MASK) {
1418                 char buffer[BLOCK_MASK];
1419                 size_t size = BLOCK_SIZE - (bytenr & BLOCK_MASK);
1420
1421                 bytenr += size;
1422                 ret = fread(buffer, size, 1, mdres->in);
1423                 if (ret != 1) {
1424                         fprintf(stderr, "Error reading in buffer %d\n", errno);
1425                         return -EIO;
1426                 }
1427         }
1428         *next = bytenr;
1429         return 0;
1430 }
1431
1432 static int wait_for_worker(struct mdrestore_struct *mdres)
1433 {
1434         int ret = 0;
1435
1436         pthread_mutex_lock(&mdres->mutex);
1437         ret = mdres->error;
1438         while (!ret && mdres->num_items > 0) {
1439                 struct timespec ts = {
1440                         .tv_sec = 0,
1441                         .tv_nsec = 10000000,
1442                 };
1443                 pthread_mutex_unlock(&mdres->mutex);
1444                 nanosleep(&ts, NULL);
1445                 pthread_mutex_lock(&mdres->mutex);
1446                 ret = mdres->error;
1447         }
1448         pthread_mutex_unlock(&mdres->mutex);
1449         return ret;
1450 }
1451
1452 static int restore_metadump(const char *input, FILE *out, int old_restore,
1453                             int num_threads)
1454 {
1455         struct meta_cluster *cluster = NULL;
1456         struct meta_cluster_header *header;
1457         struct mdrestore_struct mdrestore;
1458         u64 bytenr = 0;
1459         FILE *in = NULL;
1460         int ret = 0;
1461
1462         if (!strcmp(input, "-")) {
1463                 in = stdin;
1464         } else {
1465                 in = fopen(input, "r");
1466                 if (!in) {
1467                         perror("unable to open metadump image");
1468                         return 1;
1469                 }
1470         }
1471
1472         cluster = malloc(BLOCK_SIZE);
1473         if (!cluster) {
1474                 fprintf(stderr, "Error allocating cluster\n");
1475                 if (in != stdin)
1476                         fclose(in);
1477                 return -ENOMEM;
1478         }
1479
1480         ret = mdrestore_init(&mdrestore, in, out, old_restore, num_threads);
1481         if (ret) {
1482                 fprintf(stderr, "Error initing mdrestore %d\n", ret);
1483                 if (in != stdin)
1484                         fclose(in);
1485                 free(cluster);
1486                 return ret;
1487         }
1488
1489         while (1) {
1490                 ret = fread(cluster, BLOCK_SIZE, 1, in);
1491                 if (!ret)
1492                         break;
1493
1494                 header = &cluster->header;
1495                 if (le64_to_cpu(header->magic) != HEADER_MAGIC ||
1496                     le64_to_cpu(header->bytenr) != bytenr) {
1497                         fprintf(stderr, "bad header in metadump image\n");
1498                         ret = -EIO;
1499                         break;
1500                 }
1501                 ret = add_cluster(cluster, &mdrestore, &bytenr);
1502                 if (ret) {
1503                         fprintf(stderr, "Error adding cluster\n");
1504                         break;
1505                 }
1506
1507                 ret = wait_for_worker(&mdrestore);
1508                 if (ret) {
1509                         fprintf(stderr, "One of the threads errored out %d\n",
1510                                 ret);
1511                         break;
1512                 }
1513         }
1514
1515         mdrestore_destroy(&mdrestore);
1516         free(cluster);
1517         if (in != stdin)
1518                 fclose(in);
1519         return ret;
1520 }
1521
1522 static void print_usage(void)
1523 {
1524         fprintf(stderr, "usage: btrfs-image [options] source target\n");
1525         fprintf(stderr, "\t-r      \trestore metadump image\n");
1526         fprintf(stderr, "\t-c value\tcompression level (0 ~ 9)\n");
1527         fprintf(stderr, "\t-t value\tnumber of threads (1 ~ 32)\n");
1528         fprintf(stderr, "\t-o      \tdon't mess with the chunk tree when restoring\n");
1529         fprintf(stderr, "\t-w      \twalk all trees instead of using extent tree, do this if your extent tree is broken\n");
1530         exit(1);
1531 }
1532
1533 int main(int argc, char *argv[])
1534 {
1535         char *source;
1536         char *target;
1537         int num_threads = 0;
1538         int compress_level = 0;
1539         int create = 1;
1540         int old_restore = 0;
1541         int walk_trees = 0;
1542         int ret;
1543         FILE *out;
1544
1545         while (1) {
1546                 int c = getopt(argc, argv, "rc:t:ow");
1547                 if (c < 0)
1548                         break;
1549                 switch (c) {
1550                 case 'r':
1551                         create = 0;
1552                         break;
1553                 case 't':
1554                         num_threads = atoi(optarg);
1555                         if (num_threads <= 0 || num_threads > 32)
1556                                 print_usage();
1557                         break;
1558                 case 'c':
1559                         compress_level = atoi(optarg);
1560                         if (compress_level < 0 || compress_level > 9)
1561                                 print_usage();
1562                         break;
1563                 case 'o':
1564                         old_restore = 1;
1565                         break;
1566                 case 'w':
1567                         walk_trees = 1;
1568                         break;
1569                 default:
1570                         print_usage();
1571                 }
1572         }
1573
1574         if (old_restore && create)
1575                 print_usage();
1576
1577         argc = argc - optind;
1578         if (argc != 2)
1579                 print_usage();
1580         source = argv[optind];
1581         target = argv[optind + 1];
1582
1583         if (create && !strcmp(target, "-")) {
1584                 out = stdout;
1585         } else {
1586                 out = fopen(target, "w+");
1587                 if (!out) {
1588                         perror("unable to create target file");
1589                         exit(1);
1590                 }
1591         }
1592
1593         if (num_threads == 0 && compress_level > 0) {
1594                 num_threads = sysconf(_SC_NPROCESSORS_ONLN);
1595                 if (num_threads <= 0)
1596                         num_threads = 1;
1597         }
1598
1599         if (create)
1600                 ret = create_metadump(source, out, num_threads,
1601                                       compress_level, walk_trees);
1602         else
1603                 ret = restore_metadump(source, out, old_restore, 1);
1604
1605         if (out == stdout)
1606                 fflush(out);
1607         else
1608                 fclose(out);
1609
1610         return ret;
1611 }