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 fs_chunk {
  69         u64 logical;
  70         u64 physical;
  71         u64 bytes;
  72         struct rb_node n;
  73 };
  74
  75 struct async_work {
  76         struct list_head list;
  77         struct list_head ordered;
  78         u64 start;
  79         u64 size;
  80         u8 *buffer;
  81         size_t bufsize;
  82         int error;
  83 };
  84
  85 struct metadump_struct {
  86         struct btrfs_root *root;
  87         FILE *out;
  88
  89         struct meta_cluster *cluster;
  90
  91         pthread_t *threads;
  92         size_t num_threads;
  93         pthread_mutex_t mutex;
  94         pthread_cond_t cond;
  95         struct rb_root name_tree;
  96
  97         struct list_head list;
  98         struct list_head ordered;
  99         size_t num_items;
 100         size_t num_ready;
 101
 102         u64 pending_start;
 103         u64 pending_size;
 104
 105         int compress_level;
 106         int done;
 107         int data;
 108         int sanitize_names;
 109 };
 110
 111 struct name {
 112         struct rb_node n;
 113         char *val;
 114         char *sub;
 115         u32 len;
 116 };
 117
 118 struct mdrestore_struct {
 119         FILE *in;
 120         FILE *out;
 121
 122         pthread_t *threads;
 123         size_t num_threads;
 124         pthread_mutex_t mutex;
 125         pthread_cond_t cond;
 126
 127         struct rb_root chunk_tree;
 128         struct list_head list;
 129         size_t num_items;
 130         u64 leafsize;
 131         u64 devid;
 132         u8 uuid[BTRFS_UUID_SIZE];
 133         u8 fsid[BTRFS_FSID_SIZE];
 134
 135         int compress_method;
 136         int done;
 137         int error;
 138         int old_restore;
 139 };
 140
 141 static int search_for_chunk_blocks(struct mdrestore_struct *mdres,
 142                                    u64 search, u64 cluster_bytenr);
 143 static struct extent_buffer *alloc_dummy_eb(u64 bytenr, u32 size);
 144
 145 static void csum_block(u8 *buf, size_t len)
 146 {
 147         char result[BTRFS_CRC32_SIZE];
 148         u32 crc = ~(u32)0;
 149         crc = crc32c(crc, buf + BTRFS_CSUM_SIZE, len - BTRFS_CSUM_SIZE);
 150         btrfs_csum_final(crc, result);
 151         memcpy(buf, result, BTRFS_CRC32_SIZE);
 152 }
 153
 154 static int has_name(struct btrfs_key *key)
 155 {
 156         switch (key->type) {
 157         case BTRFS_DIR_ITEM_KEY:
 158         case BTRFS_DIR_INDEX_KEY:
 159         case BTRFS_INODE_REF_KEY:
 160         case BTRFS_INODE_EXTREF_KEY:
 161                 return 1;
 162         default:
 163                 break;
 164         }
 165
 166         return 0;
 167 }
 168
 169 static char *generate_garbage(u32 name_len)
 170 {
 171         char *buf = malloc(name_len);
 172         int i;
 173
 174         if (!buf)
 175                 return NULL;
 176
 177         for (i = 0; i < name_len; i++) {
 178                 char c = rand() % 94 + 33;
 179
 180                 if (c == '/')
 181                         c++;
 182                 buf[i] = c;
 183         }
 184
 185         return buf;
 186 }
 187
 188 static int name_cmp(struct rb_node *a, struct rb_node *b, int fuzz)
 189 {
 190         struct name *entry = rb_entry(a, struct name, n);
 191         struct name *ins = rb_entry(b, struct name, n);
 192         u32 len;
 193
 194         len = min(ins->len, entry->len);
 195         return memcmp(ins->val, entry->val, len);
 196 }
 197
 198 static int chunk_cmp(struct rb_node *a, struct rb_node *b, int fuzz)
 199 {
 200         struct fs_chunk *entry = rb_entry(a, struct fs_chunk, n);
 201         struct fs_chunk *ins = rb_entry(b, struct fs_chunk, n);
 202
 203         if (fuzz && ins->logical >= entry->logical &&
 204             ins->logical < entry->logical + entry->bytes)
 205                 return 0;
 206
 207         if (ins->logical < entry->logical)
 208                 return -1;
 209         else if (ins->logical > entry->logical)
 210                 return 1;
 211         return 0;
 212 }
 213
 214 static void tree_insert(struct rb_root *root, struct rb_node *ins,
 215                         int (*cmp)(struct rb_node *a, struct rb_node *b,
 216                                    int fuzz))
 217 {
 218         struct rb_node ** p = &root->rb_node;
 219         struct rb_node * parent = NULL;
 220         int dir;
 221
 222         while(*p) {
 223                 parent = *p;
 224
 225                 dir = cmp(*p, ins, 0);
 226                 if (dir < 0)
 227                         p = &(*p)->rb_left;
 228                 else if (dir > 0)
 229                         p = &(*p)->rb_right;
 230                 else
 231                         BUG();
 232         }
 233
 234         rb_link_node(ins, parent, p);
 235         rb_insert_color(ins, root);
 236 }
 237
 238 static struct rb_node *tree_search(struct rb_root *root,
 239                                    struct rb_node *search,
 240                                    int (*cmp)(struct rb_node *a,
 241                                               struct rb_node *b, int fuzz),
 242                                    int fuzz)
 243 {
 244         struct rb_node *n = root->rb_node;
 245         int dir;
 246
 247         while (n) {
 248                 dir = cmp(n, search, fuzz);
 249                 if (dir < 0)
 250                         n = n->rb_left;
 251                 else if (dir > 0)
 252                         n = n->rb_right;
 253                 else
 254                         return n;
 255         }
 256
 257         return NULL;
 258 }
 259
 260 static char *find_collision(struct metadump_struct *md, char *name,
 261                             u32 name_len)
 262 {
 263         struct name *val;
 264         struct rb_node *entry;
 265         struct name tmp;
 266         unsigned long checksum;
 267         int found = 0;
 268         int i;
 269
 270         tmp.val = name;
 271         tmp.len = name_len;
 272         entry = tree_search(&md->name_tree, &tmp.n, name_cmp, 0);
 273         if (entry) {
 274                 val = rb_entry(entry, struct name, n);
 275                 free(name);
 276                 return val->sub;
 277         }
 278
 279         val = malloc(sizeof(struct name));
 280         if (!val) {
 281                 fprintf(stderr, "Couldn't sanitize name, enomem\n");
 282                 return NULL;
 283         }
 284
 285         memset(val, 0, sizeof(*val));
 286
 287         val->val = name;
 288         val->len = name_len;
 289         val->sub = malloc(name_len);
 290         if (!val->sub) {
 291                 fprintf(stderr, "Couldn't sanitize name, enomem\n");
 292                 free(val);
 293                 return NULL;
 294         }
 295
 296         checksum = crc32c(~1, val->val, name_len);
 297         memset(val->sub, ' ', name_len);
 298         i = 0;
 299         while (1) {
 300                 if (crc32c(~1, val->sub, name_len) == checksum &&
 301                     memcmp(val->sub, val->val, val->len)) {
 302                         found = 1;
 303                         break;
 304                 }
 305
 306                 if (val->sub[i] == 127) {
 307                         do {
 308                                 i++;
 309                                 if (i > name_len)
 310                                         break;
 311                         } while (val->sub[i] == 127);
 312
 313                         if (i > name_len)
 314                                 break;
 315                         val->sub[i]++;
 316                         if (val->sub[i] == '/')
 317                                 val->sub[i]++;
 318                         memset(val->sub, ' ', i);
 319                         i = 0;
 320                         continue;
 321                 } else {
 322                         val->sub[i]++;
 323                         if (val->sub[i] == '/')
 324                                 val->sub[i]++;
 325                 }
 326         }
 327
 328         if (!found) {
 329                 fprintf(stderr, "Couldn't find a collision for '%.*s', "
 330                         "generating normal garbage, it won't match indexes\n",
 331                         val->len, val->val);
 332                 for (i = 0; i < name_len; i++) {
 333                         char c = rand() % 94 + 33;
 334
 335                         if (c == '/')
 336                                 c++;
 337                         val->sub[i] = c;
 338                 }
 339         }
 340
 341         tree_insert(&md->name_tree, &val->n, name_cmp);
 342         return val->sub;
 343 }
 344
 345 static void sanitize_dir_item(struct metadump_struct *md, struct extent_buffer *eb,
 346                               int slot)
 347 {
 348         struct btrfs_dir_item *dir_item;
 349         char *buf;
 350         char *garbage;
 351         unsigned long name_ptr;
 352         u32 total_len;
 353         u32 cur = 0;
 354         u32 this_len;
 355         u32 name_len;
 356         int free_garbage = (md->sanitize_names == 1);
 357
 358         dir_item = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
 359         total_len = btrfs_item_size_nr(eb, slot);
 360         while (cur < total_len) {
 361                 this_len = sizeof(*dir_item) +
 362                         btrfs_dir_name_len(eb, dir_item) +
 363                         btrfs_dir_data_len(eb, dir_item);
 364                 name_ptr = (unsigned long)(dir_item + 1);
 365                 name_len = btrfs_dir_name_len(eb, dir_item);
 366
 367                 if (md->sanitize_names > 1) {
 368                         buf = malloc(name_len);
 369                         if (!buf) {
 370                                 fprintf(stderr, "Couldn't sanitize name, "
 371                                         "enomem\n");
 372                                 return;
 373                         }
 374                         read_extent_buffer(eb, buf, name_ptr, name_len);
 375                         garbage = find_collision(md, buf, name_len);
 376                 } else {
 377                         garbage = generate_garbage(name_len);
 378                 }
 379                 if (!garbage) {
 380                         fprintf(stderr, "Couldn't sanitize name, enomem\n");
 381                         return;
 382                 }
 383                 write_extent_buffer(eb, garbage, name_ptr, name_len);
 384                 cur += this_len;
 385                 dir_item = (struct btrfs_dir_item *)((char *)dir_item +
 386                                                      this_len);
 387                 if (free_garbage)
 388                         free(garbage);
 389         }
 390 }
 391
 392 static void sanitize_inode_ref(struct metadump_struct *md,
 393                                struct extent_buffer *eb, int slot, int ext)
 394 {
 395         struct btrfs_inode_extref *extref;
 396         struct btrfs_inode_ref *ref;
 397         char *garbage, *buf;
 398         unsigned long ptr;
 399         unsigned long name_ptr;
 400         u32 item_size;
 401         u32 cur_offset = 0;
 402         int len;
 403         int free_garbage = (md->sanitize_names == 1);
 404
 405         item_size = btrfs_item_size_nr(eb, slot);
 406         ptr = btrfs_item_ptr_offset(eb, slot);
 407         while (cur_offset < item_size) {
 408                 if (ext) {
 409                         extref = (struct btrfs_inode_extref *)(ptr +
 410                                                                cur_offset);
 411                         name_ptr = (unsigned long)(&extref->name);
 412                         len = btrfs_inode_extref_name_len(eb, extref);
 413                         cur_offset += sizeof(*extref);
 414                 } else {
 415                         ref = (struct btrfs_inode_ref *)(ptr + cur_offset);
 416                         len = btrfs_inode_ref_name_len(eb, ref);
 417                         name_ptr = (unsigned long)(ref + 1);
 418                         cur_offset += sizeof(*ref);
 419                 }
 420                 cur_offset += len;
 421
 422                 if (md->sanitize_names > 1) {
 423                         buf = malloc(len);
 424                         if (!buf) {
 425                                 fprintf(stderr, "Couldn't sanitize name, "
 426                                         "enomem\n");
 427                                 return;
 428                         }
 429                         read_extent_buffer(eb, buf, name_ptr, len);
 430                         garbage = find_collision(md, buf, len);
 431                 } else {
 432                         garbage = generate_garbage(len);
 433                 }
 434
 435                 if (!garbage) {
 436                         fprintf(stderr, "Couldn't sanitize name, enomem\n");
 437                         return;
 438                 }
 439                 write_extent_buffer(eb, garbage, name_ptr, len);
 440                 if (free_garbage)
 441                         free(garbage);
 442         }
 443 }
 444
 445 static void sanitize_name(struct metadump_struct *md, u8 *dst,
 446                           struct extent_buffer *src, struct btrfs_key *key,
 447                           int slot)
 448 {
 449         struct extent_buffer *eb;
 450
 451         eb = alloc_dummy_eb(src->start, src->len);
 452         if (!eb) {
 453                 fprintf(stderr, "Couldn't sanitize name, no memory\n");
 454                 return;
 455         }
 456
 457         memcpy(eb->data, dst, eb->len);
 458
 459         switch (key->type) {
 460         case BTRFS_DIR_ITEM_KEY:
 461         case BTRFS_DIR_INDEX_KEY:
 462                 sanitize_dir_item(md, eb, slot);
 463                 break;
 464         case BTRFS_INODE_REF_KEY:
 465                 sanitize_inode_ref(md, eb, slot, 0);
 466                 break;
 467         case BTRFS_INODE_EXTREF_KEY:
 468                 sanitize_inode_ref(md, eb, slot, 1);
 469                 break;
 470         default:
 471                 break;
 472         }
 473
 474         memcpy(dst, eb->data, eb->len);
 475         free(eb);
 476 }
 477
 478 /*
 479  * zero inline extents and csum items
 480  */
 481 static void zero_items(struct metadump_struct *md, u8 *dst,
 482                        struct extent_buffer *src)
 483 {
 484         struct btrfs_file_extent_item *fi;
 485         struct btrfs_item *item;
 486         struct btrfs_key key;
 487         u32 nritems = btrfs_header_nritems(src);
 488         size_t size;
 489         unsigned long ptr;
 490         int i, extent_type;
 491
 492         for (i = 0; i < nritems; i++) {
 493                 item = btrfs_item_nr(src, i);
 494                 btrfs_item_key_to_cpu(src, &key, i);
 495                 if (key.type == BTRFS_CSUM_ITEM_KEY) {
 496                         size = btrfs_item_size_nr(src, i);
 497                         memset(dst + btrfs_leaf_data(src) +
 498                                btrfs_item_offset_nr(src, i), 0, size);
 499                         continue;
 500                 }
 501
 502                 if (md->sanitize_names && has_name(&key)) {
 503                         sanitize_name(md, dst, src, &key, i);
 504                         continue;
 505                 }
 506
 507                 if (key.type != BTRFS_EXTENT_DATA_KEY)
 508                         continue;
 509
 510                 fi = btrfs_item_ptr(src, i, struct btrfs_file_extent_item);
 511                 extent_type = btrfs_file_extent_type(src, fi);
 512                 if (extent_type != BTRFS_FILE_EXTENT_INLINE)
 513                         continue;
 514
 515                 ptr = btrfs_file_extent_inline_start(fi);
 516                 size = btrfs_file_extent_inline_item_len(src, item);
 517                 memset(dst + ptr, 0, size);
 518         }
 519 }
 520
 521 /*
 522  * copy buffer and zero useless data in the buffer
 523  */
 524 static void copy_buffer(struct metadump_struct *md, u8 *dst,
 525                         struct extent_buffer *src)
 526 {
 527         int level;
 528         size_t size;
 529         u32 nritems;
 530
 531         memcpy(dst, src->data, src->len);
 532         if (src->start == BTRFS_SUPER_INFO_OFFSET)
 533                 return;
 534
 535         level = btrfs_header_level(src);
 536         nritems = btrfs_header_nritems(src);
 537
 538         if (nritems == 0) {
 539                 size = sizeof(struct btrfs_header);
 540                 memset(dst + size, 0, src->len - size);
 541         } else if (level == 0) {
 542                 size = btrfs_leaf_data(src) +
 543                         btrfs_item_offset_nr(src, nritems - 1) -
 544                         btrfs_item_nr_offset(nritems);
 545                 memset(dst + btrfs_item_nr_offset(nritems), 0, size);
 546                 zero_items(md, dst, src);
 547         } else {
 548                 size = offsetof(struct btrfs_node, ptrs) +
 549                         sizeof(struct btrfs_key_ptr) * nritems;
 550                 memset(dst + size, 0, src->len - size);
 551         }
 552         csum_block(dst, src->len);
 553 }
 554
 555 static void *dump_worker(void *data)
 556 {
 557         struct metadump_struct *md = (struct metadump_struct *)data;
 558         struct async_work *async;
 559         int ret;
 560
 561         while (1) {
 562                 pthread_mutex_lock(&md->mutex);
 563                 while (list_empty(&md->list)) {
 564                         if (md->done) {
 565                                 pthread_mutex_unlock(&md->mutex);
 566                                 goto out;
 567                         }
 568                         pthread_cond_wait(&md->cond, &md->mutex);
 569                 }
 570                 async = list_entry(md->list.next, struct async_work, list);
 571                 list_del_init(&async->list);
 572                 pthread_mutex_unlock(&md->mutex);
 573
 574                 if (md->compress_level > 0) {
 575                         u8 *orig = async->buffer;
 576
 577                         async->bufsize = compressBound(async->size);
 578                         async->buffer = malloc(async->bufsize);
 579
 580                         ret = compress2(async->buffer,
 581                                          (unsigned long *)&async->bufsize,
 582                                          orig, async->size, md->compress_level);
 583
 584                         if (ret != Z_OK)
 585                                 async->error = 1;
 586
 587                         free(orig);
 588                 }
 589
 590                 pthread_mutex_lock(&md->mutex);
 591                 md->num_ready++;
 592                 pthread_mutex_unlock(&md->mutex);
 593         }
 594 out:
 595         pthread_exit(NULL);
 596 }
 597
 598 static void meta_cluster_init(struct metadump_struct *md, u64 start)
 599 {
 600         struct meta_cluster_header *header;
 601
 602         md->num_items = 0;
 603         md->num_ready = 0;
 604         header = &md->cluster->header;
 605         header->magic = cpu_to_le64(HEADER_MAGIC);
 606         header->bytenr = cpu_to_le64(start);
 607         header->nritems = cpu_to_le32(0);
 608         header->compress = md->compress_level > 0 ?
 609                            COMPRESS_ZLIB : COMPRESS_NONE;
 610 }
 611
 612 static int metadump_init(struct metadump_struct *md, struct btrfs_root *root,
 613                          FILE *out, int num_threads, int compress_level,
 614                          int sanitize_names)
 615 {
 616         int i, ret = 0;
 617
 618         memset(md, 0, sizeof(*md));
 619         pthread_cond_init(&md->cond, NULL);
 620         pthread_mutex_init(&md->mutex, NULL);
 621         INIT_LIST_HEAD(&md->list);
 622         INIT_LIST_HEAD(&md->ordered);
 623         md->root = root;
 624         md->out = out;
 625         md->pending_start = (u64)-1;
 626         md->compress_level = compress_level;
 627         md->cluster = calloc(1, BLOCK_SIZE);
 628         md->sanitize_names = sanitize_names;
 629         if (sanitize_names > 1)
 630                 crc32c_optimization_init();
 631
 632         if (!md->cluster) {
 633                 pthread_cond_destroy(&md->cond);
 634                 pthread_mutex_destroy(&md->mutex);
 635                 return -ENOMEM;
 636         }
 637
 638         meta_cluster_init(md, 0);
 639         if (!num_threads)
 640                 return 0;
 641
 642         md->name_tree.rb_node = NULL;
 643         md->num_threads = num_threads;
 644         md->threads = calloc(num_threads, sizeof(pthread_t));
 645         if (!md->threads) {
 646                 free(md->cluster);
 647                 pthread_cond_destroy(&md->cond);
 648                 pthread_mutex_destroy(&md->mutex);
 649                 return -ENOMEM;
 650         }
 651
 652         for (i = 0; i < num_threads; i++) {
 653                 ret = pthread_create(md->threads + i, NULL, dump_worker, md);
 654                 if (ret)
 655                         break;
 656         }
 657
 658         if (ret) {
 659                 pthread_mutex_lock(&md->mutex);
 660                 md->done = 1;
 661                 pthread_cond_broadcast(&md->cond);
 662                 pthread_mutex_unlock(&md->mutex);
 663
 664                 for (i--; i >= 0; i--)
 665                         pthread_join(md->threads[i], NULL);
 666
 667                 pthread_cond_destroy(&md->cond);
 668                 pthread_mutex_destroy(&md->mutex);
 669                 free(md->cluster);
 670                 free(md->threads);
 671         }
 672
 673         return ret;
 674 }
 675
 676 static void metadump_destroy(struct metadump_struct *md)
 677 {
 678         int i;
 679         struct rb_node *n;
 680
 681         pthread_mutex_lock(&md->mutex);
 682         md->done = 1;
 683         pthread_cond_broadcast(&md->cond);
 684         pthread_mutex_unlock(&md->mutex);
 685
 686         for (i = 0; i < md->num_threads; i++)
 687                 pthread_join(md->threads[i], NULL);
 688
 689         pthread_cond_destroy(&md->cond);
 690         pthread_mutex_destroy(&md->mutex);
 691
 692         while ((n = rb_first(&md->name_tree))) {
 693                 struct name *name;
 694
 695                 name = rb_entry(n, struct name, n);
 696                 rb_erase(n, &md->name_tree);
 697                 free(name->val);
 698                 free(name->sub);
 699                 free(name);
 700         }
 701         free(md->threads);
 702         free(md->cluster);
 703 }
 704
 705 static int write_zero(FILE *out, size_t size)
 706 {
 707         static char zero[BLOCK_SIZE];
 708         return fwrite(zero, size, 1, out);
 709 }
 710
 711 static int write_buffers(struct metadump_struct *md, u64 *next)
 712 {
 713         struct meta_cluster_header *header = &md->cluster->header;
 714         struct meta_cluster_item *item;
 715         struct async_work *async;
 716         u64 bytenr = 0;
 717         u32 nritems = 0;
 718         int ret;
 719         int err = 0;
 720
 721         if (list_empty(&md->ordered))
 722                 goto out;
 723
 724         /* wait until all buffers are compressed */
 725         while (md->num_items > md->num_ready) {
 726                 struct timespec ts = {
 727                         .tv_sec = 0,
 728                         .tv_nsec = 10000000,
 729                 };
 730                 pthread_mutex_unlock(&md->mutex);
 731                 nanosleep(&ts, NULL);
 732                 pthread_mutex_lock(&md->mutex);
 733         }
 734
 735         /* setup and write index block */
 736         list_for_each_entry(async, &md->ordered, ordered) {
 737                 item = md->cluster->items + nritems;
 738                 item->bytenr = cpu_to_le64(async->start);
 739                 item->size = cpu_to_le32(async->bufsize);
 740                 nritems++;
 741         }
 742         header->nritems = cpu_to_le32(nritems);
 743
 744         ret = fwrite(md->cluster, BLOCK_SIZE, 1, md->out);
 745         if (ret != 1) {
 746                 fprintf(stderr, "Error writing out cluster: %d\n", errno);
 747                 return -EIO;
 748         }
 749
 750         /* write buffers */
 751         bytenr += le64_to_cpu(header->bytenr) + BLOCK_SIZE;
 752         while (!list_empty(&md->ordered)) {
 753                 async = list_entry(md->ordered.next, struct async_work,
 754                                    ordered);
 755                 list_del_init(&async->ordered);
 756
 757                 bytenr += async->bufsize;
 758                 if (!err)
 759                         ret = fwrite(async->buffer, async->bufsize, 1,
 760                                      md->out);
 761                 if (ret != 1) {
 762                         err = -EIO;
 763                         ret = 0;
 764                         fprintf(stderr, "Error writing out cluster: %d\n",
 765                                 errno);
 766                 }
 767
 768                 free(async->buffer);
 769                 free(async);
 770         }
 771
 772         /* zero unused space in the last block */
 773         if (!err && bytenr & BLOCK_MASK) {
 774                 size_t size = BLOCK_SIZE - (bytenr & BLOCK_MASK);
 775
 776                 bytenr += size;
 777                 ret = write_zero(md->out, size);
 778                 if (ret != 1) {
 779                         fprintf(stderr, "Error zeroing out buffer: %d\n",
 780                                 errno);
 781                         err = -EIO;
 782                 }
 783         }
 784 out:
 785         *next = bytenr;
 786         return err;
 787 }
 788
 789 static int read_data_extent(struct metadump_struct *md,
 790                             struct async_work *async)
 791 {
 792         struct btrfs_multi_bio *multi = NULL;
 793         struct btrfs_device *device;
 794         u64 bytes_left = async->size;
 795         u64 logical = async->start;
 796         u64 offset = 0;
 797         u64 bytenr;
 798         u64 read_len;
 799         ssize_t done;
 800         int fd;
 801         int ret;
 802
 803         while (bytes_left) {
 804                 read_len = bytes_left;
 805                 ret = btrfs_map_block(&md->root->fs_info->mapping_tree, READ,
 806                                       logical, &read_len, &multi, 0, NULL);
 807                 if (ret) {
 808                         fprintf(stderr, "Couldn't map data block %d\n", ret);
 809                         return ret;
 810                 }
 811
 812                 device = multi->stripes[0].dev;
 813
 814                 if (device->fd == 0) {
 815                         fprintf(stderr,
 816                                 "Device we need to read from is not open\n");
 817                         free(multi);
 818                         return -EIO;
 819                 }
 820                 fd = device->fd;
 821                 bytenr = multi->stripes[0].physical;
 822                 free(multi);
 823
 824                 read_len = min(read_len, bytes_left);
 825                 done = pread64(fd, async->buffer+offset, read_len, bytenr);
 826                 if (done < read_len) {
 827                         if (done < 0)
 828                                 fprintf(stderr, "Error reading extent %d\n",
 829                                         errno);
 830                         else
 831                                 fprintf(stderr, "Short read\n");
 832                         return -EIO;
 833                 }
 834
 835                 bytes_left -= done;
 836                 offset += done;
 837                 logical += done;
 838         }
 839
 840         return 0;
 841 }
 842
 843 static int flush_pending(struct metadump_struct *md, int done)
 844 {
 845         struct async_work *async = NULL;
 846         struct extent_buffer *eb;
 847         u64 blocksize = md->root->nodesize;
 848         u64 start;
 849         u64 size;
 850         size_t offset;
 851         int ret = 0;
 852
 853         if (md->pending_size) {
 854                 async = calloc(1, sizeof(*async));
 855                 if (!async)
 856                         return -ENOMEM;
 857
 858                 async->start = md->pending_start;
 859                 async->size = md->pending_size;
 860                 async->bufsize = async->size;
 861                 async->buffer = malloc(async->bufsize);
 862                 if (!async->buffer) {
 863                         free(async);
 864                         return -ENOMEM;
 865                 }
 866                 offset = 0;
 867                 start = async->start;
 868                 size = async->size;
 869
 870                 if (md->data) {
 871                         ret = read_data_extent(md, async);
 872                         if (ret) {
 873                                 free(async->buffer);
 874                                 free(async);
 875                                 return ret;
 876                         }
 877                 }
 878
 879                 while (!md->data && size > 0) {
 880                         u64 this_read = min(blocksize, size);
 881                         eb = read_tree_block(md->root, start, this_read, 0);
 882                         if (!eb) {
 883                                 free(async->buffer);
 884                                 free(async);
 885                                 fprintf(stderr,
 886                                         "Error reading metadata block\n");
 887                                 return -EIO;
 888                         }
 889                         copy_buffer(md, async->buffer + offset, eb);
 890                         free_extent_buffer(eb);
 891                         start += this_read;
 892                         offset += this_read;
 893                         size -= this_read;
 894                 }
 895
 896                 md->pending_start = (u64)-1;
 897                 md->pending_size = 0;
 898         } else if (!done) {
 899                 return 0;
 900         }
 901
 902         pthread_mutex_lock(&md->mutex);
 903         if (async) {
 904                 list_add_tail(&async->ordered, &md->ordered);
 905                 md->num_items++;
 906                 if (md->compress_level > 0) {
 907                         list_add_tail(&async->list, &md->list);
 908                         pthread_cond_signal(&md->cond);
 909                 } else {
 910                         md->num_ready++;
 911                 }
 912         }
 913         if (md->num_items >= ITEMS_PER_CLUSTER || done) {
 914                 ret = write_buffers(md, &start);
 915                 if (ret)
 916                         fprintf(stderr, "Error writing buffers %d\n",
 917                                 errno);
 918                 else
 919                         meta_cluster_init(md, start);
 920         }
 921         pthread_mutex_unlock(&md->mutex);
 922         return ret;
 923 }
 924
 925 static int add_extent(u64 start, u64 size, struct metadump_struct *md,
 926                       int data)
 927 {
 928         int ret;
 929         if (md->data != data ||
 930             md->pending_size + size > MAX_PENDING_SIZE ||
 931             md->pending_start + md->pending_size != start) {
 932                 ret = flush_pending(md, 0);
 933                 if (ret)
 934                         return ret;
 935                 md->pending_start = start;
 936         }
 937         readahead_tree_block(md->root, start, size, 0);
 938         md->pending_size += size;
 939         md->data = data;
 940         return 0;
 941 }
 942
 943 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
 944 static int is_tree_block(struct btrfs_root *extent_root,
 945                          struct btrfs_path *path, u64 bytenr)
 946 {
 947         struct extent_buffer *leaf;
 948         struct btrfs_key key;
 949         u64 ref_objectid;
 950         int ret;
 951
 952         leaf = path->nodes[0];
 953         while (1) {
 954                 struct btrfs_extent_ref_v0 *ref_item;
 955                 path->slots[0]++;
 956                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
 957                         ret = btrfs_next_leaf(extent_root, path);
 958                         if (ret < 0)
 959                                 return ret;
 960                         if (ret > 0)
 961                                 break;
 962                         leaf = path->nodes[0];
 963                 }
 964                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 965                 if (key.objectid != bytenr)
 966                         break;
 967                 if (key.type != BTRFS_EXTENT_REF_V0_KEY)
 968                         continue;
 969                 ref_item = btrfs_item_ptr(leaf, path->slots[0],
 970                                           struct btrfs_extent_ref_v0);
 971                 ref_objectid = btrfs_ref_objectid_v0(leaf, ref_item);
 972                 if (ref_objectid < BTRFS_FIRST_FREE_OBJECTID)
 973                         return 1;
 974                 break;
 975         }
 976         return 0;
 977 }
 978 #endif
 979
 980 static int copy_tree_blocks(struct btrfs_root *root, struct extent_buffer *eb,
 981                             struct metadump_struct *metadump, int root_tree)
 982 {
 983         struct extent_buffer *tmp;
 984         struct btrfs_root_item *ri;
 985         struct btrfs_key key;
 986         u64 bytenr;
 987         int level;
 988         int nritems = 0;
 989         int i = 0;
 990         int ret;
 991
 992         ret = add_extent(btrfs_header_bytenr(eb), root->leafsize, metadump, 0);
 993         if (ret) {
 994                 fprintf(stderr, "Error adding metadata block\n");
 995                 return ret;
 996         }
 997
 998         if (btrfs_header_level(eb) == 0 && !root_tree)
 999                 return 0;
1000
1001         level = btrfs_header_level(eb);
1002         nritems = btrfs_header_nritems(eb);
1003         for (i = 0; i < nritems; i++) {
1004                 if (level == 0) {
1005                         btrfs_item_key_to_cpu(eb, &key, i);
1006                         if (key.type != BTRFS_ROOT_ITEM_KEY)
1007                                 continue;
1008                         ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
1009                         bytenr = btrfs_disk_root_bytenr(eb, ri);
1010                         tmp = read_tree_block(root, bytenr, root->leafsize, 0);
1011                         if (!tmp) {
1012                                 fprintf(stderr,
1013                                         "Error reading log root block\n");
1014                                 return -EIO;
1015                         }
1016                         ret = copy_tree_blocks(root, tmp, metadump, 0);
1017                         free_extent_buffer(tmp);
1018                         if (ret)
1019                                 return ret;
1020                 } else {
1021                         bytenr = btrfs_node_blockptr(eb, i);
1022                         tmp = read_tree_block(root, bytenr, root->leafsize, 0);
1023                         if (!tmp) {
1024                                 fprintf(stderr, "Error reading log block\n");
1025                                 return -EIO;
1026                         }
1027                         ret = copy_tree_blocks(root, tmp, metadump, root_tree);
1028                         free_extent_buffer(tmp);
1029                         if (ret)
1030                                 return ret;
1031                 }
1032         }
1033
1034         return 0;
1035 }
1036
1037 static int copy_log_trees(struct btrfs_root *root,
1038                           struct metadump_struct *metadump,
1039                           struct btrfs_path *path)
1040 {
1041         u64 blocknr = btrfs_super_log_root(root->fs_info->super_copy);
1042
1043         if (blocknr == 0)
1044                 return 0;
1045
1046         if (!root->fs_info->log_root_tree ||
1047             !root->fs_info->log_root_tree->node) {
1048                 fprintf(stderr, "Error copying tree log, it wasn't setup\n");
1049                 return -EIO;
1050         }
1051
1052         return copy_tree_blocks(root, root->fs_info->log_root_tree->node,
1053                                 metadump, 1);
1054 }
1055
1056 static int copy_space_cache(struct btrfs_root *root,
1057                             struct metadump_struct *metadump,
1058                             struct btrfs_path *path)
1059 {
1060         struct extent_buffer *leaf;
1061         struct btrfs_file_extent_item *fi;
1062         struct btrfs_key key;
1063         u64 bytenr, num_bytes;
1064         int ret;
1065
1066         root = root->fs_info->tree_root;
1067
1068         key.objectid = 0;
1069         key.type = BTRFS_EXTENT_DATA_KEY;
1070         key.offset = 0;
1071
1072         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1073         if (ret < 0) {
1074                 fprintf(stderr, "Error searching for free space inode %d\n",
1075                         ret);
1076                 return ret;
1077         }
1078
1079         while (1) {
1080                 leaf = path->nodes[0];
1081                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
1082                         ret = btrfs_next_leaf(root, path);
1083                         if (ret < 0) {
1084                                 fprintf(stderr, "Error going to next leaf "
1085                                         "%d\n", ret);
1086                                 return ret;
1087                         }
1088                         if (ret > 0)
1089                                 break;
1090                         leaf = path->nodes[0];
1091                 }
1092
1093                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1094                 if (key.type != BTRFS_EXTENT_DATA_KEY) {
1095                         path->slots[0]++;
1096                         continue;
1097                 }
1098
1099                 fi = btrfs_item_ptr(leaf, path->slots[0],
1100                                     struct btrfs_file_extent_item);
1101                 if (btrfs_file_extent_type(leaf, fi) !=
1102                     BTRFS_FILE_EXTENT_REG) {
1103                         path->slots[0]++;
1104                         continue;
1105                 }
1106
1107                 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1108                 num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
1109                 ret = add_extent(bytenr, num_bytes, metadump, 1);
1110                 if (ret) {
1111                         fprintf(stderr, "Error adding space cache blocks %d\n",
1112                                 ret);
1113                         btrfs_release_path(root, path);
1114                         return ret;
1115                 }
1116                 path->slots[0]++;
1117         }
1118
1119         return 0;
1120 }
1121
1122 static int copy_from_extent_tree(struct metadump_struct *metadump,
1123                                  struct btrfs_path *path)
1124 {
1125         struct btrfs_root *extent_root;
1126         struct extent_buffer *leaf;
1127         struct btrfs_extent_item *ei;
1128         struct btrfs_key key;
1129         u64 bytenr;
1130         u64 num_bytes;
1131         int ret;
1132
1133         extent_root = metadump->root->fs_info->extent_root;
1134         bytenr = BTRFS_SUPER_INFO_OFFSET + 4096;
1135         key.objectid = bytenr;
1136         key.type = BTRFS_EXTENT_ITEM_KEY;
1137         key.offset = 0;
1138
1139         ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
1140         if (ret < 0) {
1141                 fprintf(stderr, "Error searching extent root %d\n", ret);
1142                 return ret;
1143         }
1144         ret = 0;
1145
1146         while (1) {
1147                 leaf = path->nodes[0];
1148                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
1149                         ret = btrfs_next_leaf(extent_root, path);
1150                         if (ret < 0) {
1151                                 fprintf(stderr, "Error going to next leaf %d"
1152                                         "\n", ret);
1153                                 break;
1154                         }
1155                         if (ret > 0) {
1156                                 ret = 0;
1157                                 break;
1158                         }
1159                         leaf = path->nodes[0];
1160                 }
1161
1162                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1163                 if (key.objectid < bytenr ||
1164                     (key.type != BTRFS_EXTENT_ITEM_KEY &&
1165                      key.type != BTRFS_METADATA_ITEM_KEY)) {
1166                         path->slots[0]++;
1167                         continue;
1168                 }
1169
1170                 bytenr = key.objectid;
1171                 if (key.type == BTRFS_METADATA_ITEM_KEY)
1172                         num_bytes = key.offset;
1173                 else
1174                         num_bytes = extent_root->leafsize;
1175
1176                 if (btrfs_item_size_nr(leaf, path->slots[0]) > sizeof(*ei)) {
1177                         ei = btrfs_item_ptr(leaf, path->slots[0],
1178                                             struct btrfs_extent_item);
1179                         if (btrfs_extent_flags(leaf, ei) &
1180                             BTRFS_EXTENT_FLAG_TREE_BLOCK) {
1181                                 ret = add_extent(bytenr, num_bytes, metadump,
1182                                                  0);
1183                                 if (ret) {
1184                                         fprintf(stderr, "Error adding block "
1185                                                 "%d\n", ret);
1186                                         break;
1187                                 }
1188                         }
1189                 } else {
1190 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1191                         ret = is_tree_block(extent_root, path, bytenr);
1192                         if (ret < 0) {
1193                                 fprintf(stderr, "Error checking tree block "
1194                                         "%d\n", ret);
1195                                 break;
1196                         }
1197
1198                         if (ret) {
1199                                 ret = add_extent(bytenr, num_bytes, metadump,
1200                                                  0);
1201                                 if (ret) {
1202                                         fprintf(stderr, "Error adding block "
1203                                                 "%d\n", ret);
1204                                         break;
1205                                 }
1206                         }
1207                         ret = 0;
1208 #else
1209                         fprintf(stderr, "Either extent tree corruption or "
1210                                 "you haven't built with V0 support\n");
1211                         ret = -EIO;
1212                         break;
1213 #endif
1214                 }
1215                 bytenr += num_bytes;
1216         }
1217
1218         btrfs_release_path(extent_root, path);
1219
1220         return ret;
1221 }
1222
1223 static int create_metadump(const char *input, FILE *out, int num_threads,
1224                            int compress_level, int sanitize, int walk_trees)
1225 {
1226         struct btrfs_root *root;
1227         struct btrfs_path *path = NULL;
1228         struct metadump_struct metadump;
1229         int ret;
1230         int err = 0;
1231
1232         root = open_ctree(input, 0, 0);
1233         if (!root) {
1234                 fprintf(stderr, "Open ctree failed\n");
1235                 return -EIO;
1236         }
1237
1238         BUG_ON(root->nodesize != root->leafsize);
1239
1240         ret = metadump_init(&metadump, root, out, num_threads,
1241                             compress_level, sanitize);
1242         if (ret) {
1243                 fprintf(stderr, "Error initing metadump %d\n", ret);
1244                 close_ctree(root);
1245                 return ret;
1246         }
1247
1248         ret = add_extent(BTRFS_SUPER_INFO_OFFSET, 4096, &metadump, 0);
1249         if (ret) {
1250                 fprintf(stderr, "Error adding metadata %d\n", ret);
1251                 err = ret;
1252                 goto out;
1253         }
1254
1255         path = btrfs_alloc_path();
1256         if (!path) {
1257                 fprintf(stderr, "Out of memory allocing path\n");
1258                 err = -ENOMEM;
1259                 goto out;
1260         }
1261
1262         if (walk_trees) {
1263                 ret = copy_tree_blocks(root, root->fs_info->chunk_root->node,
1264                                        &metadump, 1);
1265                 if (ret) {
1266                         err = ret;
1267                         goto out;
1268                 }
1269
1270                 ret = copy_tree_blocks(root, root->fs_info->tree_root->node,
1271                                        &metadump, 1);
1272                 if (ret) {
1273                         err = ret;
1274                         goto out;
1275                 }
1276         } else {
1277                 ret = copy_from_extent_tree(&metadump, path);
1278                 if (ret) {
1279                         err = ret;
1280                         goto out;
1281                 }
1282         }
1283
1284         ret = copy_log_trees(root, &metadump, path);
1285         if (ret) {
1286                 err = ret;
1287                 goto out;
1288         }
1289
1290         ret = copy_space_cache(root, &metadump, path);
1291 out:
1292         ret = flush_pending(&metadump, 1);
1293         if (ret) {
1294                 if (!err)
1295                         err = ret;
1296                 fprintf(stderr, "Error flushing pending %d\n", ret);
1297         }
1298
1299         metadump_destroy(&metadump);
1300
1301         btrfs_free_path(path);
1302         ret = close_ctree(root);
1303         return err ? err : ret;
1304 }
1305
1306 static void update_super_old(u8 *buffer)
1307 {
1308         struct btrfs_super_block *super = (struct btrfs_super_block *)buffer;
1309         struct btrfs_chunk *chunk;
1310         struct btrfs_disk_key *key;
1311         u32 sectorsize = btrfs_super_sectorsize(super);
1312         u64 flags = btrfs_super_flags(super);
1313
1314         flags |= BTRFS_SUPER_FLAG_METADUMP;
1315         btrfs_set_super_flags(super, flags);
1316
1317         key = (struct btrfs_disk_key *)(super->sys_chunk_array);
1318         chunk = (struct btrfs_chunk *)(super->sys_chunk_array +
1319                                        sizeof(struct btrfs_disk_key));
1320
1321         btrfs_set_disk_key_objectid(key, BTRFS_FIRST_CHUNK_TREE_OBJECTID);
1322         btrfs_set_disk_key_type(key, BTRFS_CHUNK_ITEM_KEY);
1323         btrfs_set_disk_key_offset(key, 0);
1324
1325         btrfs_set_stack_chunk_length(chunk, (u64)-1);
1326         btrfs_set_stack_chunk_owner(chunk, BTRFS_EXTENT_TREE_OBJECTID);
1327         btrfs_set_stack_chunk_stripe_len(chunk, 64 * 1024);
1328         btrfs_set_stack_chunk_type(chunk, BTRFS_BLOCK_GROUP_SYSTEM);
1329         btrfs_set_stack_chunk_io_align(chunk, sectorsize);
1330         btrfs_set_stack_chunk_io_width(chunk, sectorsize);
1331         btrfs_set_stack_chunk_sector_size(chunk, sectorsize);
1332         btrfs_set_stack_chunk_num_stripes(chunk, 1);
1333         btrfs_set_stack_chunk_sub_stripes(chunk, 0);
1334         chunk->stripe.devid = super->dev_item.devid;
1335         chunk->stripe.offset = cpu_to_le64(0);
1336         memcpy(chunk->stripe.dev_uuid, super->dev_item.uuid, BTRFS_UUID_SIZE);
1337         btrfs_set_super_sys_array_size(super, sizeof(*key) + sizeof(*chunk));
1338         csum_block(buffer, 4096);
1339 }
1340
1341 static int update_super(u8 *buffer)
1342 {
1343         struct btrfs_super_block *super = (struct btrfs_super_block *)buffer;
1344         struct btrfs_chunk *chunk;
1345         struct btrfs_disk_key *disk_key;
1346         struct btrfs_key key;
1347         u32 new_array_size = 0;
1348         u32 array_size;
1349         u32 cur = 0;
1350         u32 new_cur = 0;
1351         u8 *ptr, *write_ptr;
1352         int old_num_stripes;
1353
1354         write_ptr = ptr = super->sys_chunk_array;
1355         array_size = btrfs_super_sys_array_size(super);
1356
1357         while (cur < array_size) {
1358                 disk_key = (struct btrfs_disk_key *)ptr;
1359                 btrfs_disk_key_to_cpu(&key, disk_key);
1360
1361                 new_array_size += sizeof(*disk_key);
1362                 memmove(write_ptr, ptr, sizeof(*disk_key));
1363
1364                 write_ptr += sizeof(*disk_key);
1365                 ptr += sizeof(*disk_key);
1366                 cur += sizeof(*disk_key);
1367                 new_cur += sizeof(*disk_key);
1368
1369                 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
1370                         chunk = (struct btrfs_chunk *)ptr;
1371                         old_num_stripes = btrfs_stack_chunk_num_stripes(chunk);
1372                         chunk = (struct btrfs_chunk *)write_ptr;
1373
1374                         memmove(write_ptr, ptr, sizeof(*chunk));
1375                         btrfs_set_stack_chunk_num_stripes(chunk, 1);
1376                         btrfs_set_stack_chunk_sub_stripes(chunk, 0);
1377                         btrfs_set_stack_chunk_type(chunk,
1378                                                    BTRFS_BLOCK_GROUP_SYSTEM);
1379                         chunk->stripe.devid = super->dev_item.devid;
1380                         memcpy(chunk->stripe.dev_uuid, super->dev_item.uuid,
1381                                BTRFS_UUID_SIZE);
1382                         new_array_size += sizeof(*chunk);
1383                         new_cur += sizeof(*chunk);
1384                 } else {
1385                         fprintf(stderr, "Bogus key in the sys chunk array "
1386                                 "%d\n", key.type);
1387                         return -EIO;
1388                 }
1389                 write_ptr += sizeof(*chunk);
1390                 ptr += btrfs_chunk_item_size(old_num_stripes);
1391                 cur += btrfs_chunk_item_size(old_num_stripes);
1392         }
1393
1394         btrfs_set_super_sys_array_size(super, new_array_size);
1395         csum_block(buffer, 4096);
1396
1397         return 0;
1398 }
1399
1400 static struct extent_buffer *alloc_dummy_eb(u64 bytenr, u32 size)
1401 {
1402         struct extent_buffer *eb;
1403
1404         eb = malloc(sizeof(struct extent_buffer) + size);
1405         if (!eb)
1406                 return NULL;
1407         memset(eb, 0, sizeof(struct extent_buffer) + size);
1408
1409         eb->start = bytenr;
1410         eb->len = size;
1411         return eb;
1412 }
1413
1414 static void truncate_item(struct extent_buffer *eb, int slot, u32 new_size)
1415 {
1416         struct btrfs_item *item;
1417         u32 nritems;
1418         u32 old_size;
1419         u32 old_data_start;
1420         u32 size_diff;
1421         u32 data_end;
1422         int i;
1423
1424         old_size = btrfs_item_size_nr(eb, slot);
1425         if (old_size == new_size)
1426                 return;
1427
1428         nritems = btrfs_header_nritems(eb);
1429         data_end = btrfs_item_offset_nr(eb, nritems - 1);
1430
1431         old_data_start = btrfs_item_offset_nr(eb, slot);
1432         size_diff = old_size - new_size;
1433
1434         for (i = slot; i < nritems; i++) {
1435                 u32 ioff;
1436                 item = btrfs_item_nr(eb, i);
1437                 ioff = btrfs_item_offset(eb, item);
1438                 btrfs_set_item_offset(eb, item, ioff + size_diff);
1439         }
1440
1441         memmove_extent_buffer(eb, btrfs_leaf_data(eb) + data_end + size_diff,
1442                               btrfs_leaf_data(eb) + data_end,
1443                               old_data_start + new_size - data_end);
1444         item = btrfs_item_nr(eb, slot);
1445         btrfs_set_item_size(eb, item, new_size);
1446 }
1447
1448 static int fixup_chunk_tree_block(struct mdrestore_struct *mdres,
1449                                   struct async_work *async, u8 *buffer,
1450                                   size_t size)
1451 {
1452         struct extent_buffer *eb;
1453         size_t size_left = size;
1454         u64 bytenr = async->start;
1455         int i;
1456
1457         if (size_left % mdres->leafsize)
1458                 return 0;
1459
1460         eb = alloc_dummy_eb(bytenr, mdres->leafsize);
1461         if (!eb)
1462                 return -ENOMEM;
1463
1464         while (size_left) {
1465                 eb->start = bytenr;
1466                 memcpy(eb->data, buffer, mdres->leafsize);
1467
1468                 if (btrfs_header_bytenr(eb) != bytenr)
1469                         break;
1470                 if (memcmp(mdres->fsid,
1471                            eb->data + offsetof(struct btrfs_header, fsid),
1472                            BTRFS_FSID_SIZE))
1473                         break;
1474
1475                 if (btrfs_header_owner(eb) != BTRFS_CHUNK_TREE_OBJECTID)
1476                         goto next;
1477
1478                 if (btrfs_header_level(eb) != 0)
1479                         goto next;
1480
1481                 for (i = 0; i < btrfs_header_nritems(eb); i++) {
1482                         struct btrfs_chunk chunk;
1483                         struct btrfs_key key;
1484                         u64 type;
1485
1486                         btrfs_item_key_to_cpu(eb, &key, i);
1487                         if (key.type != BTRFS_CHUNK_ITEM_KEY)
1488                                 continue;
1489                         truncate_item(eb, i, sizeof(chunk));
1490                         read_extent_buffer(eb, &chunk,
1491                                            btrfs_item_ptr_offset(eb, i),
1492                                            sizeof(chunk));
1493
1494                         /* Zero out the RAID profile */
1495                         type = btrfs_stack_chunk_type(&chunk);
1496                         type &= (BTRFS_BLOCK_GROUP_DATA |
1497                                  BTRFS_BLOCK_GROUP_SYSTEM |
1498                                  BTRFS_BLOCK_GROUP_METADATA);
1499                         btrfs_set_stack_chunk_type(&chunk, type);
1500
1501                         btrfs_set_stack_chunk_num_stripes(&chunk, 1);
1502                         btrfs_set_stack_chunk_sub_stripes(&chunk, 0);
1503                         btrfs_set_stack_stripe_devid(&chunk.stripe, mdres->devid);
1504                         memcpy(chunk.stripe.dev_uuid, mdres->uuid,
1505                                BTRFS_UUID_SIZE);
1506                         write_extent_buffer(eb, &chunk,
1507                                             btrfs_item_ptr_offset(eb, i),
1508                                             sizeof(chunk));
1509                 }
1510                 memcpy(buffer, eb->data, eb->len);
1511                 csum_block(buffer, eb->len);
1512 next:
1513                 size_left -= mdres->leafsize;
1514                 buffer += mdres->leafsize;
1515                 bytenr += mdres->leafsize;
1516         }
1517
1518         return 0;
1519 }
1520
1521 static void write_backup_supers(int fd, u8 *buf)
1522 {
1523         struct btrfs_super_block *super = (struct btrfs_super_block *)buf;
1524         struct stat st;
1525         u64 size;
1526         u64 bytenr;
1527         int i;
1528         int ret;
1529
1530         if (fstat(fd, &st)) {
1531                 fprintf(stderr, "Couldn't stat restore point, won't be able "
1532                         "to write backup supers: %d\n", errno);
1533                 return;
1534         }
1535
1536         size = btrfs_device_size(fd, &st);
1537
1538         for (i = 1; i < BTRFS_SUPER_MIRROR_MAX; i++) {
1539                 bytenr = btrfs_sb_offset(i);
1540                 if (bytenr + 4096 > size)
1541                         break;
1542                 btrfs_set_super_bytenr(super, bytenr);
1543                 csum_block(buf, 4096);
1544                 ret = pwrite64(fd, buf, 4096, bytenr);
1545                 if (ret < 4096) {
1546                         if (ret < 0)
1547                                 fprintf(stderr, "Problem writing out backup "
1548                                         "super block %d, err %d\n", i, errno);
1549                         else
1550                                 fprintf(stderr, "Short write writing out "
1551                                         "backup super block\n");
1552                         break;
1553                 }
1554         }
1555 }
1556
1557 static u64 logical_to_physical(struct mdrestore_struct *mdres, u64 logical, u64 *size)
1558 {
1559         struct fs_chunk *fs_chunk;
1560         struct rb_node *entry;
1561         struct fs_chunk search;
1562         u64 offset;
1563
1564         if (logical == BTRFS_SUPER_INFO_OFFSET)
1565                 return logical;
1566
1567         search.logical = logical;
1568         entry = tree_search(&mdres->chunk_tree, &search.n, chunk_cmp, 1);
1569         if (!entry) {
1570                 if (mdres->in != stdin)
1571                         printf("Couldn't find a chunk, using logical\n");
1572                 return logical;
1573         }
1574         fs_chunk = rb_entry(entry, struct fs_chunk, n);
1575         if (fs_chunk->logical > logical || fs_chunk->logical + fs_chunk->bytes < logical)
1576                 BUG();
1577         offset = search.logical - fs_chunk->logical;
1578
1579         *size = min(*size, fs_chunk->bytes + fs_chunk->logical - logical);
1580         return fs_chunk->physical + offset;
1581 }
1582
1583 static void *restore_worker(void *data)
1584 {
1585         struct mdrestore_struct *mdres = (struct mdrestore_struct *)data;
1586         struct async_work *async;
1587         size_t size;
1588         u8 *buffer;
1589         u8 *outbuf;
1590         int outfd;
1591         int ret;
1592
1593         outfd = fileno(mdres->out);
1594         buffer = malloc(MAX_PENDING_SIZE * 2);
1595         if (!buffer) {
1596                 fprintf(stderr, "Error allocing buffer\n");
1597                 pthread_mutex_lock(&mdres->mutex);
1598                 if (!mdres->error)
1599                         mdres->error = -ENOMEM;
1600                 pthread_mutex_unlock(&mdres->mutex);
1601                 goto out;
1602         }
1603
1604         while (1) {
1605                 u64 bytenr;
1606                 off_t offset = 0;
1607                 int err = 0;
1608
1609                 pthread_mutex_lock(&mdres->mutex);
1610                 while (!mdres->leafsize || list_empty(&mdres->list)) {
1611                         if (mdres->done) {
1612                                 pthread_mutex_unlock(&mdres->mutex);
1613                                 goto out;
1614                         }
1615                         pthread_cond_wait(&mdres->cond, &mdres->mutex);
1616                 }
1617                 async = list_entry(mdres->list.next, struct async_work, list);
1618                 list_del_init(&async->list);
1619                 pthread_mutex_unlock(&mdres->mutex);
1620
1621                 if (mdres->compress_method == COMPRESS_ZLIB) {
1622                         size = MAX_PENDING_SIZE * 2;
1623                         ret = uncompress(buffer, (unsigned long *)&size,
1624                                          async->buffer, async->bufsize);
1625                         if (ret != Z_OK) {
1626                                 fprintf(stderr, "Error decompressing %d\n",
1627                                         ret);
1628                                 err = -EIO;
1629                         }
1630                         outbuf = buffer;
1631                 } else {
1632                         outbuf = async->buffer;
1633                         size = async->bufsize;
1634                 }
1635
1636                 if (async->start == BTRFS_SUPER_INFO_OFFSET) {
1637                         if (mdres->old_restore) {
1638                                 update_super_old(outbuf);
1639                         } else {
1640                                 ret = update_super(outbuf);
1641                                 if (ret)
1642                                         err = ret;
1643                         }
1644                 } else if (!mdres->old_restore) {
1645                         ret = fixup_chunk_tree_block(mdres, async, outbuf, size);
1646                         if (ret)
1647                                 err = ret;
1648                 }
1649
1650                 while (size) {
1651                         u64 chunk_size = size;
1652                         bytenr = logical_to_physical(mdres,
1653                                                      async->start + offset,
1654                                                      &chunk_size);
1655                         ret = pwrite64(outfd, outbuf+offset, chunk_size,
1656                                        bytenr);
1657                         if (ret < chunk_size) {
1658                                 if (ret < 0) {
1659                                         fprintf(stderr, "Error writing to "
1660                                                 "device %d\n", errno);
1661                                         err = errno;
1662                                         break;
1663                                 } else {
1664                                         fprintf(stderr, "Short write\n");
1665                                         err = -EIO;
1666                                         break;
1667                                 }
1668                         }
1669                         size -= chunk_size;
1670                         offset += chunk_size;
1671                 }
1672
1673                 if (async->start == BTRFS_SUPER_INFO_OFFSET)
1674                         write_backup_supers(outfd, outbuf);
1675
1676                 pthread_mutex_lock(&mdres->mutex);
1677                 if (err && !mdres->error)
1678                         mdres->error = err;
1679                 mdres->num_items--;
1680                 pthread_mutex_unlock(&mdres->mutex);
1681
1682                 free(async->buffer);
1683                 free(async);
1684         }
1685 out:
1686         free(buffer);
1687         pthread_exit(NULL);
1688 }
1689
1690 static void mdrestore_destroy(struct mdrestore_struct *mdres)
1691 {
1692         struct rb_node *n;
1693         int i;
1694
1695         while ((n = rb_first(&mdres->chunk_tree))) {
1696                 struct fs_chunk *entry;
1697
1698                 entry = rb_entry(n, struct fs_chunk, n);
1699                 rb_erase(n, &mdres->chunk_tree);
1700                 free(entry);
1701         }
1702         pthread_mutex_lock(&mdres->mutex);
1703         mdres->done = 1;
1704         pthread_cond_broadcast(&mdres->cond);
1705         pthread_mutex_unlock(&mdres->mutex);
1706
1707         for (i = 0; i < mdres->num_threads; i++)
1708                 pthread_join(mdres->threads[i], NULL);
1709
1710         pthread_cond_destroy(&mdres->cond);
1711         pthread_mutex_destroy(&mdres->mutex);
1712         free(mdres->threads);
1713 }
1714
1715 static int mdrestore_init(struct mdrestore_struct *mdres,
1716                           FILE *in, FILE *out, int old_restore,
1717                           int num_threads)
1718 {
1719         int i, ret = 0;
1720
1721         memset(mdres, 0, sizeof(*mdres));
1722         pthread_cond_init(&mdres->cond, NULL);
1723         pthread_mutex_init(&mdres->mutex, NULL);
1724         INIT_LIST_HEAD(&mdres->list);
1725         mdres->in = in;
1726         mdres->out = out;
1727         mdres->old_restore = old_restore;
1728         mdres->chunk_tree.rb_node = NULL;
1729
1730         if (!num_threads)
1731                 return 0;
1732
1733         mdres->num_threads = num_threads;
1734         mdres->threads = calloc(num_threads, sizeof(pthread_t));
1735         if (!mdres->threads)
1736                 return -ENOMEM;
1737         for (i = 0; i < num_threads; i++) {
1738                 ret = pthread_create(mdres->threads + i, NULL, restore_worker,
1739                                      mdres);
1740                 if (ret)
1741                         break;
1742         }
1743         if (ret)
1744                 mdrestore_destroy(mdres);
1745         return ret;
1746 }
1747
1748 static int fill_mdres_info(struct mdrestore_struct *mdres,
1749                            struct async_work *async)
1750 {
1751         struct btrfs_super_block *super;
1752         u8 *buffer = NULL;
1753         u8 *outbuf;
1754         int ret;
1755
1756         /* We've already been initialized */
1757         if (mdres->leafsize)
1758                 return 0;
1759
1760         if (mdres->compress_method == COMPRESS_ZLIB) {
1761                 size_t size = MAX_PENDING_SIZE * 2;
1762
1763                 buffer = malloc(MAX_PENDING_SIZE * 2);
1764                 if (!buffer)
1765                         return -ENOMEM;
1766                 ret = uncompress(buffer, (unsigned long *)&size,
1767                                  async->buffer, async->bufsize);
1768                 if (ret != Z_OK) {
1769                         fprintf(stderr, "Error decompressing %d\n", ret);
1770                         free(buffer);
1771                         return -EIO;
1772                 }
1773                 outbuf = buffer;
1774         } else {
1775                 outbuf = async->buffer;
1776         }
1777
1778         super = (struct btrfs_super_block *)outbuf;
1779         mdres->leafsize = btrfs_super_leafsize(super);
1780         memcpy(mdres->fsid, super->fsid, BTRFS_FSID_SIZE);
1781         memcpy(mdres->uuid, super->dev_item.uuid,
1782                        BTRFS_UUID_SIZE);
1783         mdres->devid = le64_to_cpu(super->dev_item.devid);
1784         free(buffer);
1785         return 0;
1786 }
1787
1788 static int add_cluster(struct meta_cluster *cluster,
1789                        struct mdrestore_struct *mdres, u64 *next)
1790 {
1791         struct meta_cluster_item *item;
1792         struct meta_cluster_header *header = &cluster->header;
1793         struct async_work *async;
1794         u64 bytenr;
1795         u32 i, nritems;
1796         int ret;
1797
1798         BUG_ON(mdres->num_items);
1799         mdres->compress_method = header->compress;
1800
1801         bytenr = le64_to_cpu(header->bytenr) + BLOCK_SIZE;
1802         nritems = le32_to_cpu(header->nritems);
1803         for (i = 0; i < nritems; i++) {
1804                 item = &cluster->items[i];
1805                 async = calloc(1, sizeof(*async));
1806                 if (!async) {
1807                         fprintf(stderr, "Error allocating async\n");
1808                         return -ENOMEM;
1809                 }
1810                 async->start = le64_to_cpu(item->bytenr);
1811                 async->bufsize = le32_to_cpu(item->size);
1812                 async->buffer = malloc(async->bufsize);
1813                 if (!async->buffer) {
1814                         fprintf(stderr, "Error allocing async buffer\n");
1815                         free(async);
1816                         return -ENOMEM;
1817                 }
1818                 ret = fread(async->buffer, async->bufsize, 1, mdres->in);
1819                 if (ret != 1) {
1820                         fprintf(stderr, "Error reading buffer %d\n", errno);
1821                         free(async->buffer);
1822                         free(async);
1823                         return -EIO;
1824                 }
1825                 bytenr += async->bufsize;
1826
1827                 pthread_mutex_lock(&mdres->mutex);
1828                 if (async->start == BTRFS_SUPER_INFO_OFFSET) {
1829                         ret = fill_mdres_info(mdres, async);
1830                         if (ret) {
1831                                 fprintf(stderr, "Error setting up restore\n");
1832                                 pthread_mutex_unlock(&mdres->mutex);
1833                                 free(async->buffer);
1834                                 free(async);
1835                                 return ret;
1836                         }
1837                 }
1838                 list_add_tail(&async->list, &mdres->list);
1839                 mdres->num_items++;
1840                 pthread_cond_signal(&mdres->cond);
1841                 pthread_mutex_unlock(&mdres->mutex);
1842         }
1843         if (bytenr & BLOCK_MASK) {
1844                 char buffer[BLOCK_MASK];
1845                 size_t size = BLOCK_SIZE - (bytenr & BLOCK_MASK);
1846
1847                 bytenr += size;
1848                 ret = fread(buffer, size, 1, mdres->in);
1849                 if (ret != 1) {
1850                         fprintf(stderr, "Error reading in buffer %d\n", errno);
1851                         return -EIO;
1852                 }
1853         }
1854         *next = bytenr;
1855         return 0;
1856 }
1857
1858 static int wait_for_worker(struct mdrestore_struct *mdres)
1859 {
1860         int ret = 0;
1861
1862         pthread_mutex_lock(&mdres->mutex);
1863         ret = mdres->error;
1864         while (!ret && mdres->num_items > 0) {
1865                 struct timespec ts = {
1866                         .tv_sec = 0,
1867                         .tv_nsec = 10000000,
1868                 };
1869                 pthread_mutex_unlock(&mdres->mutex);
1870                 nanosleep(&ts, NULL);
1871                 pthread_mutex_lock(&mdres->mutex);
1872                 ret = mdres->error;
1873         }
1874         pthread_mutex_unlock(&mdres->mutex);
1875         return ret;
1876 }
1877
1878 static int read_chunk_block(struct mdrestore_struct *mdres, u8 *buffer,
1879                             u64 bytenr, u64 item_bytenr, u32 bufsize,
1880                             u64 cluster_bytenr)
1881 {
1882         struct extent_buffer *eb;
1883         int ret = 0;
1884         int i;
1885
1886         eb = alloc_dummy_eb(bytenr, mdres->leafsize);
1887         if (!eb) {
1888                 ret = -ENOMEM;
1889                 goto out;
1890         }
1891
1892         while (item_bytenr != bytenr) {
1893                 buffer += mdres->leafsize;
1894                 item_bytenr += mdres->leafsize;
1895         }
1896
1897         memcpy(eb->data, buffer, mdres->leafsize);
1898         if (btrfs_header_bytenr(eb) != bytenr) {
1899                 fprintf(stderr, "Eb bytenr doesn't match found bytenr\n");
1900                 ret = -EIO;
1901                 goto out;
1902         }
1903
1904         if (memcmp(mdres->fsid, eb->data + offsetof(struct btrfs_header, fsid),
1905                    BTRFS_FSID_SIZE)) {
1906                 fprintf(stderr, "Fsid doesn't match\n");
1907                 ret = -EIO;
1908                 goto out;
1909         }
1910
1911         if (btrfs_header_owner(eb) != BTRFS_CHUNK_TREE_OBJECTID) {
1912                 fprintf(stderr, "Does not belong to the chunk tree\n");
1913                 ret = -EIO;
1914                 goto out;
1915         }
1916
1917         for (i = 0; i < btrfs_header_nritems(eb); i++) {
1918                 struct btrfs_chunk chunk;
1919                 struct fs_chunk *fs_chunk;
1920                 struct btrfs_key key;
1921
1922                 if (btrfs_header_level(eb)) {
1923                         u64 blockptr = btrfs_node_blockptr(eb, i);
1924
1925                         ret = search_for_chunk_blocks(mdres, blockptr,
1926                                                       cluster_bytenr);
1927                         if (ret)
1928                                 break;
1929                         continue;
1930                 }
1931
1932                 /* Yay a leaf!  We loves leafs! */
1933                 btrfs_item_key_to_cpu(eb, &key, i);
1934                 if (key.type != BTRFS_CHUNK_ITEM_KEY)
1935                         continue;
1936
1937                 fs_chunk = malloc(sizeof(struct fs_chunk));
1938                 if (!fs_chunk) {
1939                         fprintf(stderr, "Erorr allocating chunk\n");
1940                         ret = -ENOMEM;
1941                         break;
1942                 }
1943                 memset(fs_chunk, 0, sizeof(*fs_chunk));
1944                 read_extent_buffer(eb, &chunk, btrfs_item_ptr_offset(eb, i),
1945                                    sizeof(chunk));
1946
1947                 fs_chunk->logical = key.offset;
1948                 fs_chunk->physical = btrfs_stack_stripe_offset(&chunk.stripe);
1949                 fs_chunk->bytes = btrfs_stack_chunk_length(&chunk);
1950                 tree_insert(&mdres->chunk_tree, &fs_chunk->n, chunk_cmp);
1951         }
1952 out:
1953         free(eb);
1954         return ret;
1955 }
1956
1957 /* If you have to ask you aren't worthy */
1958 static int search_for_chunk_blocks(struct mdrestore_struct *mdres,
1959                                    u64 search, u64 cluster_bytenr)
1960 {
1961         struct meta_cluster *cluster;
1962         struct meta_cluster_header *header;
1963         struct meta_cluster_item *item;
1964         u64 current_cluster = cluster_bytenr, bytenr;
1965         u64 item_bytenr;
1966         u32 bufsize, nritems, i;
1967         u8 *buffer, *tmp = NULL;
1968         int ret = 0;
1969
1970         cluster = malloc(BLOCK_SIZE);
1971         if (!cluster) {
1972                 fprintf(stderr, "Error allocating cluster\n");
1973                 return -ENOMEM;
1974         }
1975
1976         buffer = malloc(MAX_PENDING_SIZE * 2);
1977         if (!buffer) {
1978                 fprintf(stderr, "Error allocing buffer\n");
1979                 free(cluster);
1980                 return -ENOMEM;
1981         }
1982
1983         if (mdres->compress_method == COMPRESS_ZLIB) {
1984                 tmp = malloc(MAX_PENDING_SIZE * 2);
1985                 if (!tmp) {
1986                         fprintf(stderr, "Error allocing tmp buffer\n");
1987                         free(cluster);
1988                         free(buffer);
1989                         return -ENOMEM;
1990                 }
1991         }
1992
1993         bytenr = current_cluster;
1994         while (1) {
1995                 if (fseek(mdres->in, current_cluster, SEEK_SET)) {
1996                         fprintf(stderr, "Error seeking: %d\n", errno);
1997                         ret = -EIO;
1998                         break;
1999                 }
2000
2001                 ret = fread(cluster, BLOCK_SIZE, 1, mdres->in);
2002                 if (ret == 0) {
2003                         if (cluster_bytenr != 0) {
2004                                 cluster_bytenr = 0;
2005                                 current_cluster = 0;
2006                                 bytenr = 0;
2007                                 continue;
2008                         }
2009                         printf("ok this is where we screwed up?\n");
2010                         ret = -EIO;
2011                         break;
2012                 } else if (ret < 0) {
2013                         fprintf(stderr, "Error reading image\n");
2014                         break;
2015                 }
2016                 ret = 0;
2017
2018                 header = &cluster->header;
2019                 if (le64_to_cpu(header->magic) != HEADER_MAGIC ||
2020                     le64_to_cpu(header->bytenr) != current_cluster) {
2021                         fprintf(stderr, "bad header in metadump image\n");
2022                         ret = -EIO;
2023                         break;
2024                 }
2025
2026                 bytenr += BLOCK_SIZE;
2027                 nritems = le32_to_cpu(header->nritems);
2028                 for (i = 0; i < nritems; i++) {
2029                         size_t size;
2030
2031                         item = &cluster->items[i];
2032                         bufsize = le32_to_cpu(item->size);
2033                         item_bytenr = le64_to_cpu(item->bytenr);
2034
2035                         if (mdres->compress_method == COMPRESS_ZLIB) {
2036                                 ret = fread(tmp, bufsize, 1, mdres->in);
2037                                 if (ret != 1) {
2038                                         fprintf(stderr, "Error reading: %d\n",
2039                                                 errno);
2040                                         ret = -EIO;
2041                                         break;
2042                                 }
2043
2044                                 size = MAX_PENDING_SIZE * 2;
2045                                 ret = uncompress(buffer,
2046                                                  (unsigned long *)&size, tmp,
2047                                                  bufsize);
2048                                 if (ret != Z_OK) {
2049                                         fprintf(stderr, "Error decompressing "
2050                                                 "%d\n", ret);
2051                                         ret = -EIO;
2052                                         break;
2053                                 }
2054                         } else {
2055                                 ret = fread(buffer, bufsize, 1, mdres->in);
2056                                 if (ret != 1) {
2057                                         fprintf(stderr, "Error reading: %d\n",
2058                                                 errno);
2059                                         ret = -EIO;
2060                                         break;
2061                                 }
2062                                 size = bufsize;
2063                         }
2064                         ret = 0;
2065
2066                         if (item_bytenr <= search &&
2067                             item_bytenr + size > search) {
2068                                 ret = read_chunk_block(mdres, buffer, search,
2069                                                        item_bytenr, size,
2070                                                        current_cluster);
2071                                 if (!ret)
2072                                         ret = 1;
2073                                 break;
2074                         }
2075                         bytenr += bufsize;
2076                 }
2077                 if (ret) {
2078                         if (ret > 0)
2079                                 ret = 0;
2080                         break;
2081                 }
2082                 if (bytenr & BLOCK_MASK)
2083                         bytenr += BLOCK_SIZE - (bytenr & BLOCK_MASK);
2084                 current_cluster = bytenr;
2085         }
2086
2087         free(tmp);
2088         free(buffer);
2089         free(cluster);
2090         return ret;
2091 }
2092
2093 static int build_chunk_tree(struct mdrestore_struct *mdres,
2094                             struct meta_cluster *cluster)
2095 {
2096         struct btrfs_super_block *super;
2097         struct meta_cluster_header *header;
2098         struct meta_cluster_item *item = NULL;
2099         u64 chunk_root_bytenr = 0;
2100         u32 i, nritems;
2101         u64 bytenr = 0;
2102         u8 *buffer;
2103         int ret;
2104
2105         /* We can't seek with stdin so don't bother doing this */
2106         if (mdres->in == stdin)
2107                 return 0;
2108
2109         ret = fread(cluster, BLOCK_SIZE, 1, mdres->in);
2110         if (ret <= 0) {
2111                 fprintf(stderr, "Error reading in cluster: %d\n", errno);
2112                 return -EIO;
2113         }
2114         ret = 0;
2115
2116         header = &cluster->header;
2117         if (le64_to_cpu(header->magic) != HEADER_MAGIC ||
2118             le64_to_cpu(header->bytenr) != 0) {
2119                 fprintf(stderr, "bad header in metadump image\n");
2120                 return -EIO;
2121         }
2122
2123         bytenr += BLOCK_SIZE;
2124         mdres->compress_method = header->compress;
2125         nritems = le32_to_cpu(header->nritems);
2126         for (i = 0; i < nritems; i++) {
2127                 item = &cluster->items[i];
2128
2129                 if (le64_to_cpu(item->bytenr) == BTRFS_SUPER_INFO_OFFSET)
2130                         break;
2131                 bytenr += le32_to_cpu(item->size);
2132                 if (fseek(mdres->in, le32_to_cpu(item->size), SEEK_CUR)) {
2133                         fprintf(stderr, "Error seeking: %d\n", errno);
2134                         return -EIO;
2135                 }
2136         }
2137
2138         if (!item || le64_to_cpu(item->bytenr) != BTRFS_SUPER_INFO_OFFSET) {
2139                 fprintf(stderr, "Huh, didn't find the super?\n");
2140                 return -EINVAL;
2141         }
2142
2143         buffer = malloc(le32_to_cpu(item->size));
2144         if (!buffer) {
2145                 fprintf(stderr, "Error allocing buffer\n");
2146                 return -ENOMEM;
2147         }
2148
2149         ret = fread(buffer, le32_to_cpu(item->size), 1, mdres->in);
2150         if (ret != 1) {
2151                 fprintf(stderr, "Error reading buffer: %d\n", errno);
2152                 free(buffer);
2153                 return -EIO;
2154         }
2155
2156         if (mdres->compress_method == COMPRESS_ZLIB) {
2157                 size_t size = MAX_PENDING_SIZE * 2;
2158                 u8 *tmp;
2159
2160                 tmp = malloc(MAX_PENDING_SIZE * 2);
2161                 if (!tmp) {
2162                         free(buffer);
2163                         return -ENOMEM;
2164                 }
2165                 ret = uncompress(tmp, (unsigned long *)&size,
2166                                  buffer, le32_to_cpu(item->size));
2167                 if (ret != Z_OK) {
2168                         fprintf(stderr, "Error decompressing %d\n", ret);
2169                         free(buffer);
2170                         free(tmp);
2171                         return -EIO;
2172                 }
2173                 free(buffer);
2174                 buffer = tmp;
2175         }
2176
2177         super = (struct btrfs_super_block *)buffer;
2178         chunk_root_bytenr = btrfs_super_chunk_root(super);
2179         mdres->leafsize = btrfs_super_leafsize(super);
2180         memcpy(mdres->fsid, super->fsid, BTRFS_FSID_SIZE);
2181         memcpy(mdres->uuid, super->dev_item.uuid,
2182                        BTRFS_UUID_SIZE);
2183         mdres->devid = le64_to_cpu(super->dev_item.devid);
2184         free(buffer);
2185
2186         return search_for_chunk_blocks(mdres, chunk_root_bytenr, 0);
2187 }
2188
2189 static int restore_metadump(const char *input, FILE *out, int old_restore,
2190                             int num_threads)
2191 {
2192         struct meta_cluster *cluster = NULL;
2193         struct meta_cluster_header *header;
2194         struct mdrestore_struct mdrestore;
2195         u64 bytenr = 0;
2196         FILE *in = NULL;
2197         int ret = 0;
2198
2199         if (!strcmp(input, "-")) {
2200                 in = stdin;
2201         } else {
2202                 in = fopen(input, "r");
2203                 if (!in) {
2204                         perror("unable to open metadump image");
2205                         return 1;
2206                 }
2207         }
2208
2209         cluster = malloc(BLOCK_SIZE);
2210         if (!cluster) {
2211                 fprintf(stderr, "Error allocating cluster\n");
2212                 if (in != stdin)
2213                         fclose(in);
2214                 return -ENOMEM;
2215         }
2216
2217         ret = mdrestore_init(&mdrestore, in, out, old_restore, num_threads);
2218         if (ret) {
2219                 fprintf(stderr, "Error initing mdrestore %d\n", ret);
2220                 if (in != stdin)
2221                         fclose(in);
2222                 free(cluster);
2223                 return ret;
2224         }
2225
2226         ret = build_chunk_tree(&mdrestore, cluster);
2227         if (ret)
2228                 goto out;
2229
2230         if (in != stdin && fseek(in, 0, SEEK_SET)) {
2231                 fprintf(stderr, "Error seeking %d\n", errno);
2232                 goto out;
2233         }
2234
2235         while (1) {
2236                 ret = fread(cluster, BLOCK_SIZE, 1, in);
2237                 if (!ret)
2238                         break;
2239
2240                 header = &cluster->header;
2241                 if (le64_to_cpu(header->magic) != HEADER_MAGIC ||
2242                     le64_to_cpu(header->bytenr) != bytenr) {
2243                         fprintf(stderr, "bad header in metadump image\n");
2244                         ret = -EIO;
2245                         break;
2246                 }
2247                 ret = add_cluster(cluster, &mdrestore, &bytenr);
2248                 if (ret) {
2249                         fprintf(stderr, "Error adding cluster\n");
2250                         break;
2251                 }
2252
2253                 ret = wait_for_worker(&mdrestore);
2254                 if (ret) {
2255                         fprintf(stderr, "One of the threads errored out %d\n",
2256                                 ret);
2257                         break;
2258                 }
2259         }
2260 out:
2261         mdrestore_destroy(&mdrestore);
2262         free(cluster);
2263         if (in != stdin)
2264                 fclose(in);
2265         return ret;
2266 }
2267
2268 static void print_usage(void)
2269 {
2270         fprintf(stderr, "usage: btrfs-image [options] source target\n");
2271         fprintf(stderr, "\t-r      \trestore metadump image\n");
2272         fprintf(stderr, "\t-c value\tcompression level (0 ~ 9)\n");
2273         fprintf(stderr, "\t-t value\tnumber of threads (1 ~ 32)\n");
2274         fprintf(stderr, "\t-o      \tdon't mess with the chunk tree when restoring\n");
2275         fprintf(stderr, "\t-s      \tsanitize file names, use once to just use garbage, use twice if you want crc collisions");
2276         fprintf(stderr, "\t-w      \twalk all trees instead of using extent tree, do this if your extent tree is broken\n");
2277         exit(1);
2278 }
2279
2280 int main(int argc, char *argv[])
2281 {
2282         char *source;
2283         char *target;
2284         int num_threads = 0;
2285         int compress_level = 0;
2286         int create = 1;
2287         int old_restore = 0;
2288         int walk_trees = 0;
2289         int ret;
2290         int sanitize = 0;
2291         FILE *out;
2292
2293         while (1) {
2294                 int c = getopt(argc, argv, "rc:t:osw");
2295                 if (c < 0)
2296                         break;
2297                 switch (c) {
2298                 case 'r':
2299                         create = 0;
2300                         break;
2301                 case 't':
2302                         num_threads = atoi(optarg);
2303                         if (num_threads <= 0 || num_threads > 32)
2304                                 print_usage();
2305                         break;
2306                 case 'c':
2307                         compress_level = atoi(optarg);
2308                         if (compress_level < 0 || compress_level > 9)
2309                                 print_usage();
2310                         break;
2311                 case 'o':
2312                         old_restore = 1;
2313                         break;
2314                 case 's':
2315                         sanitize++;
2316                         break;
2317                 case 'w':
2318                         walk_trees = 1;
2319                         break;
2320                 default:
2321                         print_usage();
2322                 }
2323         }
2324
2325         if (old_restore && create)
2326                 print_usage();
2327
2328         argc = argc - optind;
2329         if (argc != 2)
2330                 print_usage();
2331         source = argv[optind];
2332         target = argv[optind + 1];
2333
2334         if (create && !strcmp(target, "-")) {
2335                 out = stdout;
2336         } else {
2337                 out = fopen(target, "w+");
2338                 if (!out) {
2339                         perror("unable to create target file");
2340                         exit(1);
2341                 }
2342         }
2343
2344         if (num_threads == 0 && compress_level > 0) {
2345                 num_threads = sysconf(_SC_NPROCESSORS_ONLN);
2346                 if (num_threads <= 0)
2347                         num_threads = 1;
2348         }
2349
2350         if (create)
2351                 ret = create_metadump(source, out, num_threads,
2352                                       compress_level, sanitize, walk_trees);
2353         else
2354                 ret = restore_metadump(source, out, old_restore, 1);
2355
2356         if (out == stdout)
2357                 fflush(out);
2358         else
2359                 fclose(out);
2360
2361         return ret;
2362 }