convert.c

   1 /*
   2  * Copyright (C) 2007 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 600
  20 #define _GNU_SOURCE 1
  21 #ifndef __CHECKER__
  22 #include <sys/ioctl.h>
  23 #include <sys/mount.h>
  24 #endif
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <sys/acl.h>
  30 #include <fcntl.h>
  31 #include <unistd.h>
  32 #include <uuid/uuid.h>
  33 #include <linux/fs.h>
  34 #include "kerncompat.h"
  35 #include "ctree.h"
  36 #include "disk-io.h"
  37 #include "volumes.h"
  38 #include "transaction.h"
  39 #include "crc32c.h"
  40 #include "utils.h"
  41 #include <ext2fs/ext2_fs.h>
  42 #include <ext2fs/ext2fs.h>
  43 #include <ext2fs/ext2_ext_attr.h>
  44
  45 #define INO_OFFSET (BTRFS_FIRST_FREE_OBJECTID - EXT2_ROOT_INO)
  46 #define STRIPE_LEN (64 * 1024)
  47 #define EXT2_IMAGE_SUBVOL_OBJECTID BTRFS_FIRST_FREE_OBJECTID
  48
  49 /*
  50  * Open Ext2fs in readonly mode, read block allocation bitmap and
  51  * inode bitmap into memory.
  52  */
  53 static int open_ext2fs(const char *name, ext2_filsys *ret_fs)
  54 {
  55         errcode_t ret;
  56         ext2_filsys ext2_fs;
  57         ext2_ino_t ino;
  58         ret = ext2fs_open(name, 0, 0, 0, unix_io_manager, &ext2_fs);
  59         if (ret) {
  60                 fprintf(stderr, "ext2fs_open: %s\n", error_message(ret));
  61                 goto fail;
  62         }
  63         ret = ext2fs_read_inode_bitmap(ext2_fs);
  64         if (ret) {
  65                 fprintf(stderr, "ext2fs_read_inode_bitmap: %s\n",
  66                         error_message(ret));
  67                 goto fail;
  68         }
  69         ret = ext2fs_read_block_bitmap(ext2_fs);
  70         if (ret) {
  71                 fprintf(stderr, "ext2fs_read_block_bitmap: %s\n",
  72                         error_message(ret));
  73                 goto fail;
  74         }
  75         /*
  76          * search each block group for a free inode. this set up
  77          * uninit block/inode bitmaps appropriately.
  78          */
  79         ino = 1;
  80         while (ino <= ext2_fs->super->s_inodes_count) {
  81                 ext2_ino_t foo;
  82                 ext2fs_new_inode(ext2_fs, ino, 0, NULL, &foo);
  83                 ino += EXT2_INODES_PER_GROUP(ext2_fs->super);
  84         }
  85
  86         *ret_fs = ext2_fs;
  87         return 0;
  88 fail:
  89         return -1;
  90 }
  91
  92 static int close_ext2fs(ext2_filsys fs)
  93 {
  94         ext2fs_close(fs);
  95         return 0;
  96 }
  97
  98 static int ext2_alloc_block(ext2_filsys fs, u64 goal, u64 *block_ret)
  99 {
 100         blk_t block;
 101
 102         if (!ext2fs_new_block(fs, goal, NULL, &block)) {
 103                 ext2fs_fast_mark_block_bitmap(fs->block_map, block);
 104                 *block_ret = block;
 105                 return 0;
 106         }
 107         return -ENOSPC;
 108 }
 109
 110 static int ext2_free_block(ext2_filsys fs, u64 block)
 111 {
 112         BUG_ON(block != (blk_t)block);
 113         ext2fs_fast_unmark_block_bitmap(fs->block_map, block);
 114         return 0;
 115 }
 116
 117 static int cache_free_extents(struct btrfs_root *root, ext2_filsys ext2_fs)
 118
 119 {
 120         int i, ret = 0;
 121         blk_t block;
 122         u64 bytenr;
 123         u64 blocksize = ext2_fs->blocksize;
 124
 125         block = ext2_fs->super->s_first_data_block;
 126         for (; block < ext2_fs->super->s_blocks_count; block++) {
 127                 if (ext2fs_fast_test_block_bitmap(ext2_fs->block_map, block))
 128                         continue;
 129                 bytenr = block * blocksize;
 130                 ret = set_extent_dirty(&root->fs_info->free_space_cache,
 131                                        bytenr, bytenr + blocksize - 1, 0);
 132                 BUG_ON(ret);
 133         }
 134
 135         for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
 136                 bytenr = btrfs_sb_offset(i);
 137                 bytenr &= ~((u64)STRIPE_LEN - 1);
 138                 if (bytenr >= blocksize * ext2_fs->super->s_blocks_count)
 139                         break;
 140                 clear_extent_dirty(&root->fs_info->free_space_cache, bytenr,
 141                                    bytenr + STRIPE_LEN - 1, 0);
 142         }
 143
 144         clear_extent_dirty(&root->fs_info->free_space_cache,
 145                            0, BTRFS_SUPER_INFO_OFFSET - 1, 0);
 146
 147         return 0;
 148 }
 149
 150 static int custom_alloc_extent(struct btrfs_root *root, u64 num_bytes,
 151                                u64 hint_byte, struct btrfs_key *ins)
 152 {
 153         u64 start;
 154         u64 end;
 155         u64 last = hint_byte;
 156         int ret;
 157         int wrapped = 0;
 158         struct btrfs_block_group_cache *cache;
 159
 160         while(1) {
 161                 ret = find_first_extent_bit(&root->fs_info->free_space_cache,
 162                                             last, &start, &end, EXTENT_DIRTY);
 163                 if (ret) {
 164                         if (wrapped++ == 0) {
 165                                 last = 0;
 166                                 continue;
 167                         } else {
 168                                 goto fail;
 169                         }
 170                 }
 171
 172                 start = max(last, start);
 173                 last = end + 1;
 174                 if (last - start < num_bytes)
 175                         continue;
 176
 177                 last = start + num_bytes;
 178                 if (test_range_bit(&root->fs_info->pinned_extents,
 179                                    start, last - 1, EXTENT_DIRTY, 0))
 180                         continue;
 181
 182                 cache = btrfs_lookup_block_group(root->fs_info, start);
 183                 BUG_ON(!cache);
 184                 if (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM ||
 185                     last > cache->key.objectid + cache->key.offset) {
 186                         last = cache->key.objectid + cache->key.offset;
 187                         continue;
 188                 }
 189
 190                 clear_extent_dirty(&root->fs_info->free_space_cache,
 191                                    start, start + num_bytes - 1, 0);
 192
 193                 ins->objectid = start;
 194                 ins->offset = num_bytes;
 195                 ins->type = BTRFS_EXTENT_ITEM_KEY;
 196                 return 0;
 197         }
 198 fail:
 199         fprintf(stderr, "not enough free space\n");
 200         return -ENOSPC;
 201 }
 202
 203 static int intersect_with_sb(u64 bytenr, u64 num_bytes)
 204 {
 205         int i;
 206         u64 offset;
 207
 208         for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
 209                 offset = btrfs_sb_offset(i);
 210                 offset &= ~((u64)STRIPE_LEN - 1);
 211
 212                 if (bytenr < offset + STRIPE_LEN &&
 213                     bytenr + num_bytes > offset)
 214                         return 1;
 215         }
 216         return 0;
 217 }
 218
 219 static int custom_free_extent(struct btrfs_root *root, u64 bytenr,
 220                               u64 num_bytes)
 221 {
 222         return intersect_with_sb(bytenr, num_bytes);
 223 }
 224
 225 struct btrfs_extent_ops extent_ops = {
 226         .alloc_extent = custom_alloc_extent,
 227         .free_extent = custom_free_extent,
 228 };
 229
 230 struct dir_iterate_data {
 231         struct btrfs_trans_handle *trans;
 232         struct btrfs_root *root;
 233         struct btrfs_inode_item *inode;
 234         u64 objectid;
 235         u64 index_cnt;
 236         u64 parent;
 237         int errcode;
 238 };
 239
 240 static u8 filetype_conversion_table[EXT2_FT_MAX] = {
 241         [EXT2_FT_UNKNOWN]       = BTRFS_FT_UNKNOWN,
 242         [EXT2_FT_REG_FILE]      = BTRFS_FT_REG_FILE,
 243         [EXT2_FT_DIR]           = BTRFS_FT_DIR,
 244         [EXT2_FT_CHRDEV]        = BTRFS_FT_CHRDEV,
 245         [EXT2_FT_BLKDEV]        = BTRFS_FT_BLKDEV,
 246         [EXT2_FT_FIFO]          = BTRFS_FT_FIFO,
 247         [EXT2_FT_SOCK]          = BTRFS_FT_SOCK,
 248         [EXT2_FT_SYMLINK]       = BTRFS_FT_SYMLINK,
 249 };
 250
 251 static int dir_iterate_proc(ext2_ino_t dir, int entry,
 252                             struct ext2_dir_entry *old,
 253                             int offset, int blocksize,
 254                             char *buf,void *priv_data)
 255 {
 256         int ret;
 257         int file_type;
 258         u64 objectid;
 259         u64 inode_size;
 260         char dotdot[] = "..";
 261         struct btrfs_key location;
 262         struct ext2_dir_entry_2 *dirent = (struct ext2_dir_entry_2 *)old;
 263         struct dir_iterate_data *idata = (struct dir_iterate_data *)priv_data;
 264
 265         objectid = dirent->inode + INO_OFFSET;
 266         if (!strncmp(dirent->name, dotdot, dirent->name_len)) {
 267                 if (dirent->name_len == 2) {
 268                         BUG_ON(idata->parent != 0);
 269                         idata->parent = objectid;
 270                 }
 271                 return 0;
 272         }
 273         if (dirent->inode < EXT2_GOOD_OLD_FIRST_INO)
 274                 return 0;
 275
 276         location.objectid = objectid;
 277         location.offset = 0;
 278         btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
 279
 280         file_type = dirent->file_type;
 281         BUG_ON(file_type > EXT2_FT_SYMLINK);
 282         ret = btrfs_insert_dir_item(idata->trans, idata->root,
 283                                     dirent->name, dirent->name_len,
 284                                     idata->objectid, &location,
 285                                     filetype_conversion_table[file_type],
 286                                     idata->index_cnt);
 287         if (ret)
 288                 goto fail;
 289         ret = btrfs_insert_inode_ref(idata->trans, idata->root,
 290                                      dirent->name, dirent->name_len,
 291                                      objectid, idata->objectid,
 292                                      idata->index_cnt);
 293         if (ret)
 294                 goto fail;
 295         idata->index_cnt++;
 296         inode_size = btrfs_stack_inode_size(idata->inode) +
 297                      dirent->name_len * 2;
 298         btrfs_set_stack_inode_size(idata->inode, inode_size);
 299         return 0;
 300 fail:
 301         idata->errcode = ret;
 302         return BLOCK_ABORT;
 303 }
 304
 305 static int create_dir_entries(struct btrfs_trans_handle *trans,
 306                               struct btrfs_root *root, u64 objectid,
 307                               struct btrfs_inode_item *btrfs_inode,
 308                               ext2_filsys ext2_fs, ext2_ino_t ext2_ino)
 309 {
 310         int ret;
 311         errcode_t err;
 312         struct dir_iterate_data data = {
 313                 .trans          = trans,
 314                 .root           = root,
 315                 .inode          = btrfs_inode,
 316                 .objectid       = objectid,
 317                 .index_cnt      = 2,
 318                 .parent         = 0,
 319                 .errcode        = 0,
 320         };
 321
 322         err = ext2fs_dir_iterate2(ext2_fs, ext2_ino, 0, NULL,
 323                                   dir_iterate_proc, &data);
 324         if (err)
 325                 goto error;
 326         ret = data.errcode;
 327         if (ret == 0 && data.parent == objectid) {
 328                 ret = btrfs_insert_inode_ref(trans, root, "..", 2,
 329                                              objectid, objectid, 0);
 330         }
 331         return ret;
 332 error:
 333         fprintf(stderr, "ext2fs_dir_iterate2: %s\n", error_message(err));
 334         return -1;
 335 }
 336
 337 static int read_disk_extent(struct btrfs_root *root, u64 bytenr,
 338                             u32 num_bytes, char *buffer)
 339 {
 340         int ret;
 341         struct btrfs_fs_devices *fs_devs = root->fs_info->fs_devices;
 342
 343         ret = pread(fs_devs->latest_bdev, buffer, num_bytes, bytenr);
 344         if (ret != num_bytes)
 345                 goto fail;
 346         ret = 0;
 347 fail:
 348         if (ret > 0)
 349                 ret = -1;
 350         return ret;
 351 }
 352 /*
 353  * Record a file extent. Do all the required works, such as inserting
 354  * file extent item, inserting extent item and backref item into extent
 355  * tree and updating block accounting.
 356  */
 357 static int record_file_extent(struct btrfs_trans_handle *trans,
 358                               struct btrfs_root *root, u64 objectid,
 359                               struct btrfs_inode_item *inode,
 360                               u64 file_pos, u64 disk_bytenr,
 361                               u64 num_bytes, int checksum)
 362 {
 363         int ret;
 364         struct btrfs_fs_info *info = root->fs_info;
 365         struct btrfs_root *extent_root = info->extent_root;
 366         struct extent_buffer *leaf;
 367         struct btrfs_file_extent_item *fi;
 368         struct btrfs_key ins_key;
 369         struct btrfs_path path;
 370         struct btrfs_extent_item *ei;
 371         u32 blocksize = root->sectorsize;
 372         u64 nbytes;
 373
 374         if (disk_bytenr == 0) {
 375                 ret = btrfs_insert_file_extent(trans, root, objectid,
 376                                                 file_pos, disk_bytenr,
 377                                                 num_bytes, num_bytes);
 378                 return ret;
 379         }
 380
 381         btrfs_init_path(&path);
 382
 383         if (checksum) {
 384                 u64 offset;
 385                 char *buffer;
 386
 387                 ret = -ENOMEM;
 388                 buffer = malloc(blocksize);
 389                 if (!buffer)
 390                         goto fail;
 391                 for (offset = 0; offset < num_bytes; offset += blocksize) {
 392                         ret = read_disk_extent(root, disk_bytenr + offset,
 393                                                 blocksize, buffer);
 394                         if (ret)
 395                                 break;
 396                         ret = btrfs_csum_file_block(trans,
 397                                                     root->fs_info->csum_root,
 398                                                     disk_bytenr + num_bytes,
 399                                                     disk_bytenr + offset,
 400                                                     buffer, blocksize);
 401                         if (ret)
 402                                 break;
 403                 }
 404                 free(buffer);
 405                 if (ret)
 406                         goto fail;
 407         }
 408
 409         ins_key.objectid = objectid;
 410         ins_key.offset = file_pos;
 411         btrfs_set_key_type(&ins_key, BTRFS_EXTENT_DATA_KEY);
 412         ret = btrfs_insert_empty_item(trans, root, &path, &ins_key,
 413                                       sizeof(*fi));
 414         if (ret)
 415                 goto fail;
 416         leaf = path.nodes[0];
 417         fi = btrfs_item_ptr(leaf, path.slots[0],
 418                             struct btrfs_file_extent_item);
 419         btrfs_set_file_extent_generation(leaf, fi, trans->transid);
 420         btrfs_set_file_extent_type(leaf, fi, BTRFS_FILE_EXTENT_REG);
 421         btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
 422         btrfs_set_file_extent_disk_num_bytes(leaf, fi, num_bytes);
 423         btrfs_set_file_extent_offset(leaf, fi, 0);
 424         btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
 425         btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
 426         btrfs_set_file_extent_compression(leaf, fi, 0);
 427         btrfs_set_file_extent_encryption(leaf, fi, 0);
 428         btrfs_set_file_extent_other_encoding(leaf, fi, 0);
 429         btrfs_mark_buffer_dirty(leaf);
 430
 431         nbytes = btrfs_stack_inode_nbytes(inode) + num_bytes;
 432         btrfs_set_stack_inode_nbytes(inode, nbytes);
 433
 434         btrfs_release_path(root, &path);
 435
 436         ins_key.objectid = disk_bytenr;
 437         ins_key.offset = num_bytes;
 438         ins_key.type = BTRFS_EXTENT_ITEM_KEY;
 439
 440         ret = btrfs_insert_empty_item(trans, extent_root, &path,
 441                                       &ins_key, sizeof(*ei));
 442         if (ret == 0) {
 443                 leaf = path.nodes[0];
 444                 ei = btrfs_item_ptr(leaf, path.slots[0],
 445                                     struct btrfs_extent_item);
 446
 447                 btrfs_set_extent_refs(leaf, ei, 0);
 448                 btrfs_set_extent_generation(leaf, ei, 0);
 449                 btrfs_set_extent_flags(leaf, ei, BTRFS_EXTENT_FLAG_DATA);
 450
 451                 btrfs_mark_buffer_dirty(leaf);
 452
 453                 ret = btrfs_update_block_group(trans, root, disk_bytenr,
 454                                                num_bytes, 1, 0);
 455                 if (ret)
 456                         goto fail;
 457         } else if (ret != -EEXIST) {
 458                 goto fail;
 459         }
 460         btrfs_extent_post_op(trans, extent_root);
 461
 462         ret = btrfs_inc_extent_ref(trans, root, disk_bytenr, num_bytes, 0,
 463                                    root->root_key.objectid,
 464                                    objectid, file_pos);
 465         if (ret)
 466                 goto fail;
 467         ret = 0;
 468 fail:
 469         btrfs_release_path(root, &path);
 470         return ret;
 471 }
 472
 473 static int record_file_blocks(struct btrfs_trans_handle *trans,
 474                               struct btrfs_root *root, u64 objectid,
 475                               struct btrfs_inode_item *inode,
 476                               u64 file_block, u64 disk_block,
 477                               u64 num_blocks, int checksum)
 478 {
 479         u64 file_pos = file_block * root->sectorsize;
 480         u64 disk_bytenr = disk_block * root->sectorsize;
 481         u64 num_bytes = num_blocks * root->sectorsize;
 482         return record_file_extent(trans, root, objectid, inode, file_pos,
 483                                   disk_bytenr, num_bytes, checksum);
 484 }
 485
 486 struct blk_iterate_data {
 487         struct btrfs_trans_handle *trans;
 488         struct btrfs_root *root;
 489         struct btrfs_inode_item *inode;
 490         u64 objectid;
 491         u64 first_block;
 492         u64 disk_block;
 493         u64 num_blocks;
 494         u64 boundary;
 495         int checksum;
 496         int errcode;
 497 };
 498
 499 static int block_iterate_proc(ext2_filsys ext2_fs,
 500                               u64 disk_block, u64 file_block,
 501                               struct blk_iterate_data *idata)
 502 {
 503         int ret;
 504         int sb_region;
 505         int do_barrier;
 506         struct btrfs_root *root = idata->root;
 507         struct btrfs_trans_handle *trans = idata->trans;
 508         struct btrfs_block_group_cache *cache;
 509         u64 bytenr = disk_block * root->sectorsize;
 510
 511         sb_region = intersect_with_sb(bytenr, root->sectorsize);
 512         do_barrier = sb_region || disk_block >= idata->boundary;
 513         if ((idata->num_blocks > 0 && do_barrier) ||
 514             (file_block > idata->first_block + idata->num_blocks) ||
 515             (disk_block != idata->disk_block + idata->num_blocks)) {
 516                 if (idata->num_blocks > 0) {
 517                         ret = record_file_blocks(trans, root, idata->objectid,
 518                                         idata->inode, idata->first_block,
 519                                         idata->disk_block, idata->num_blocks,
 520                                         idata->checksum);
 521                         if (ret)
 522                                 goto fail;
 523                         idata->first_block += idata->num_blocks;
 524                         idata->num_blocks = 0;
 525                 }
 526                 if (file_block > idata->first_block) {
 527                         ret = record_file_blocks(trans, root, idata->objectid,
 528                                         idata->inode, idata->first_block,
 529                                         0, file_block - idata->first_block,
 530                                         idata->checksum);
 531                         if (ret)
 532                                 goto fail;
 533                 }
 534
 535                 if (sb_region) {
 536                         bytenr += STRIPE_LEN - 1;
 537                         bytenr &= ~((u64)STRIPE_LEN - 1);
 538                 } else {
 539                         cache = btrfs_lookup_block_group(root->fs_info, bytenr);
 540                         BUG_ON(!cache);
 541                         bytenr = cache->key.objectid + cache->key.offset;
 542                 }
 543
 544                 idata->first_block = file_block;
 545                 idata->disk_block = disk_block;
 546                 idata->boundary = bytenr / root->sectorsize;
 547         }
 548         idata->num_blocks++;
 549         return 0;
 550 fail:
 551         idata->errcode = ret;
 552         return BLOCK_ABORT;
 553 }
 554
 555 static int __block_iterate_proc(ext2_filsys fs, blk_t *blocknr,
 556                                 e2_blkcnt_t blockcnt, blk_t ref_block,
 557                                 int ref_offset, void *priv_data)
 558 {
 559         struct blk_iterate_data *idata;
 560         idata = (struct blk_iterate_data *)priv_data;
 561         return block_iterate_proc(fs, *blocknr, blockcnt, idata);
 562 }
 563
 564 /*
 565  * traverse file's data blocks, record these data blocks as file extents.
 566  */
 567 static int create_file_extents(struct btrfs_trans_handle *trans,
 568                                struct btrfs_root *root, u64 objectid,
 569                                struct btrfs_inode_item *btrfs_inode,
 570                                ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
 571                                int datacsum, int packing)
 572 {
 573         int ret;
 574         char *buffer = NULL;
 575         errcode_t err;
 576         u32 last_block;
 577         u32 sectorsize = root->sectorsize;
 578         u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
 579         struct blk_iterate_data data = {
 580                 .trans          = trans,
 581                 .root           = root,
 582                 .inode          = btrfs_inode,
 583                 .objectid       = objectid,
 584                 .first_block    = 0,
 585                 .disk_block     = 0,
 586                 .num_blocks     = 0,
 587                 .boundary       = (u64)-1,
 588                 .checksum       = datacsum,
 589                 .errcode        = 0,
 590         };
 591         err = ext2fs_block_iterate2(ext2_fs, ext2_ino, BLOCK_FLAG_DATA_ONLY,
 592                                     NULL, __block_iterate_proc, &data);
 593         if (err)
 594                 goto error;
 595         ret = data.errcode;
 596         if (ret)
 597                 goto fail;
 598         if (packing && data.first_block == 0 && data.num_blocks > 0 &&
 599             inode_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
 600                 u64 num_bytes = data.num_blocks * sectorsize;
 601                 u64 disk_bytenr = data.disk_block * sectorsize;
 602                 u64 nbytes;
 603
 604                 buffer = malloc(num_bytes);
 605                 if (!buffer)
 606                         return -ENOMEM;
 607                 ret = read_disk_extent(root, disk_bytenr, num_bytes, buffer);
 608                 if (ret)
 609                         goto fail;
 610                 if (num_bytes > inode_size)
 611                         num_bytes = inode_size;
 612                 ret = btrfs_insert_inline_extent(trans, root, objectid,
 613                                                  0, buffer, num_bytes);
 614                 if (ret)
 615                         goto fail;
 616                 nbytes = btrfs_stack_inode_nbytes(btrfs_inode) + num_bytes;
 617                 btrfs_set_stack_inode_nbytes(btrfs_inode, nbytes);
 618         } else if (data.num_blocks > 0) {
 619                 ret = record_file_blocks(trans, root, objectid, btrfs_inode,
 620                                          data.first_block, data.disk_block,
 621                                          data.num_blocks, data.checksum);
 622                 if (ret)
 623                         goto fail;
 624         }
 625         data.first_block += data.num_blocks;
 626         last_block = (inode_size + sectorsize - 1) / sectorsize;
 627         if (last_block > data.first_block) {
 628                 ret = record_file_blocks(trans, root, objectid, btrfs_inode,
 629                                          data.first_block, 0, last_block -
 630                                          data.first_block, data.checksum);
 631         }
 632 fail:
 633         if (buffer)
 634                 free(buffer);
 635         return ret;
 636 error:
 637         fprintf(stderr, "ext2fs_block_iterate2: %s\n", error_message(err));
 638         return -1;
 639 }
 640
 641 static int create_symbol_link(struct btrfs_trans_handle *trans,
 642                               struct btrfs_root *root, u64 objectid,
 643                               struct btrfs_inode_item *btrfs_inode,
 644                               ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
 645                               struct ext2_inode *ext2_inode)
 646 {
 647         int ret;
 648         char *pathname;
 649         u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
 650         if (ext2fs_inode_data_blocks(ext2_fs, ext2_inode)) {
 651                 btrfs_set_stack_inode_size(btrfs_inode, inode_size + 1);
 652                 ret = create_file_extents(trans, root, objectid, btrfs_inode,
 653                                           ext2_fs, ext2_ino, 1, 1);
 654                 btrfs_set_stack_inode_size(btrfs_inode, inode_size);
 655                 return ret;
 656         }
 657
 658         pathname = (char *)&(ext2_inode->i_block[0]);
 659         BUG_ON(pathname[inode_size] != 0);
 660         ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
 661                                          pathname, inode_size + 1);
 662         btrfs_set_stack_inode_nbytes(btrfs_inode, inode_size + 1);
 663         return ret;
 664 }
 665
 666 /*
 667  * Following xattr/acl related codes are based on codes in
 668  * fs/ext3/xattr.c and fs/ext3/acl.c
 669  */
 670 #define EXT2_XATTR_BHDR(ptr) ((struct ext2_ext_attr_header *)(ptr))
 671 #define EXT2_XATTR_BFIRST(ptr) \
 672         ((struct ext2_ext_attr_entry *)(EXT2_XATTR_BHDR(ptr) + 1))
 673 #define EXT2_XATTR_IHDR(inode) \
 674         ((struct ext2_ext_attr_header *) ((void *)(inode) + \
 675                 EXT2_GOOD_OLD_INODE_SIZE + (inode)->i_extra_isize))
 676 #define EXT2_XATTR_IFIRST(inode) \
 677         ((struct ext2_ext_attr_entry *) ((void *)EXT2_XATTR_IHDR(inode) + \
 678                 sizeof(EXT2_XATTR_IHDR(inode)->h_magic)))
 679
 680 static int ext2_xattr_check_names(struct ext2_ext_attr_entry *entry,
 681                                   const void *end)
 682 {
 683         struct ext2_ext_attr_entry *next;
 684
 685         while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
 686                 next = EXT2_EXT_ATTR_NEXT(entry);
 687                 if ((void *)next >= end)
 688                         return -EIO;
 689                 entry = next;
 690         }
 691         return 0;
 692 }
 693
 694 static int ext2_xattr_check_block(const char *buf, size_t size)
 695 {
 696         int error;
 697         struct ext2_ext_attr_header *header = EXT2_XATTR_BHDR(buf);
 698
 699         if (header->h_magic != EXT2_EXT_ATTR_MAGIC ||
 700             header->h_blocks != 1)
 701                 return -EIO;
 702         error = ext2_xattr_check_names(EXT2_XATTR_BFIRST(buf), buf + size);
 703         return error;
 704 }
 705
 706 static int ext2_xattr_check_entry(struct ext2_ext_attr_entry *entry,
 707                                   size_t size)
 708 {
 709         size_t value_size = entry->e_value_size;
 710
 711         if (entry->e_value_block != 0 || value_size > size ||
 712             entry->e_value_offs + value_size > size)
 713                 return -EIO;
 714         return 0;
 715 }
 716
 717 #define EXT2_ACL_VERSION        0x0001
 718
 719 typedef struct {
 720         __le16          e_tag;
 721         __le16          e_perm;
 722         __le32          e_id;
 723 } ext2_acl_entry;
 724
 725 typedef struct {
 726         __le16          e_tag;
 727         __le16          e_perm;
 728 } ext2_acl_entry_short;
 729
 730 typedef struct {
 731         __le32          a_version;
 732 } ext2_acl_header;
 733
 734 static inline int ext2_acl_count(size_t size)
 735 {
 736         ssize_t s;
 737         size -= sizeof(ext2_acl_header);
 738         s = size - 4 * sizeof(ext2_acl_entry_short);
 739         if (s < 0) {
 740                 if (size % sizeof(ext2_acl_entry_short))
 741                         return -1;
 742                 return size / sizeof(ext2_acl_entry_short);
 743         } else {
 744                 if (s % sizeof(ext2_acl_entry))
 745                         return -1;
 746                 return s / sizeof(ext2_acl_entry) + 4;
 747         }
 748 }
 749
 750 #define ACL_EA_VERSION          0x0002
 751
 752 typedef struct {
 753         __le16          e_tag;
 754         __le16          e_perm;
 755         __le32          e_id;
 756 } acl_ea_entry;
 757
 758 typedef struct {
 759         __le32          a_version;
 760         acl_ea_entry    a_entries[0];
 761 } acl_ea_header;
 762
 763 static inline size_t acl_ea_size(int count)
 764 {
 765         return sizeof(acl_ea_header) + count * sizeof(acl_ea_entry);
 766 }
 767
 768 static int ext2_acl_to_xattr(void *dst, const void *src,
 769                              size_t dst_size, size_t src_size)
 770 {
 771         int i, count;
 772         const void *end = src + src_size;
 773         acl_ea_header *ext_acl = (acl_ea_header *)dst;
 774         acl_ea_entry *dst_entry = ext_acl->a_entries;
 775         ext2_acl_entry *src_entry;
 776
 777         if (src_size < sizeof(ext2_acl_header))
 778                 goto fail;
 779         if (((ext2_acl_header *)src)->a_version !=
 780             cpu_to_le32(EXT2_ACL_VERSION))
 781                 goto fail;
 782         src += sizeof(ext2_acl_header);
 783         count = ext2_acl_count(src_size);
 784         if (count <= 0)
 785                 goto fail;
 786
 787         BUG_ON(dst_size < acl_ea_size(count));
 788         ext_acl->a_version = cpu_to_le32(ACL_EA_VERSION);
 789         for (i = 0; i < count; i++, dst_entry++) {
 790                 src_entry = (ext2_acl_entry *)src;
 791                 if (src + sizeof(ext2_acl_entry_short) > end)
 792                         goto fail;
 793                 dst_entry->e_tag = src_entry->e_tag;
 794                 dst_entry->e_perm = src_entry->e_perm;
 795                 switch (le16_to_cpu(src_entry->e_tag)) {
 796                 case ACL_USER_OBJ:
 797                 case ACL_GROUP_OBJ:
 798                 case ACL_MASK:
 799                 case ACL_OTHER:
 800                         src += sizeof(ext2_acl_entry_short);
 801                         dst_entry->e_id = cpu_to_le32(ACL_UNDEFINED_ID);
 802                         break;
 803                 case ACL_USER:
 804                 case ACL_GROUP:
 805                         src += sizeof(ext2_acl_entry);
 806                         if (src > end)
 807                                 goto fail;
 808                         dst_entry->e_id = src_entry->e_id;
 809                         break;
 810                 default:
 811                         goto fail;
 812                 }
 813         }
 814         if (src != end)
 815                 goto fail;
 816         return 0;
 817 fail:
 818         return -EINVAL;
 819 }
 820
 821 static char *xattr_prefix_table[] = {
 822         [1] =   "user.",
 823         [2] =   "system.posix_acl_access",
 824         [3] =   "system.posix_acl_default",
 825         [4] =   "trusted.",
 826         [6] =   "security.",
 827 };
 828
 829 static int copy_single_xattr(struct btrfs_trans_handle *trans,
 830                              struct btrfs_root *root, u64 objectid,
 831                              struct ext2_ext_attr_entry *entry,
 832                              const void *data, u32 datalen)
 833 {
 834         int ret = 0;
 835         int name_len;
 836         int name_index;
 837         void *databuf = NULL;
 838         char namebuf[XATTR_NAME_MAX + 1];
 839
 840         name_index = entry->e_name_index;
 841         if (name_index >= ARRAY_SIZE(xattr_prefix_table) ||
 842             xattr_prefix_table[name_index] == NULL)
 843                 return -EOPNOTSUPP;
 844         name_len = strlen(xattr_prefix_table[name_index]) +
 845                    entry->e_name_len;
 846         if (name_len >= sizeof(namebuf))
 847                 return -ERANGE;
 848
 849         if (name_index == 2 || name_index == 3) {
 850                 size_t bufsize = acl_ea_size(ext2_acl_count(datalen));
 851                 databuf = malloc(bufsize);
 852                 if (!databuf)
 853                        return -ENOMEM;
 854                 ret = ext2_acl_to_xattr(databuf, data, bufsize, datalen);
 855                 if (ret)
 856                         goto out;
 857                 data = databuf;
 858                 datalen = bufsize;
 859         }
 860         strncpy(namebuf, xattr_prefix_table[name_index], XATTR_NAME_MAX);
 861         strncat(namebuf, EXT2_EXT_ATTR_NAME(entry), entry->e_name_len);
 862         if (name_len + datalen > BTRFS_LEAF_DATA_SIZE(root) -
 863             sizeof(struct btrfs_item) - sizeof(struct btrfs_dir_item)) {
 864                 fprintf(stderr, "skip large xattr on inode %Lu name %.*s\n",
 865                         objectid - INO_OFFSET, name_len, namebuf);
 866                 goto out;
 867         }
 868         ret = btrfs_insert_xattr_item(trans, root, namebuf, name_len,
 869                                       data, datalen, objectid);
 870 out:
 871         if (databuf)
 872                 free(databuf);
 873         return ret;
 874 }
 875
 876 static int copy_extended_attrs(struct btrfs_trans_handle *trans,
 877                                struct btrfs_root *root, u64 objectid,
 878                                struct btrfs_inode_item *btrfs_inode,
 879                                ext2_filsys ext2_fs, ext2_ino_t ext2_ino)
 880 {
 881         int ret = 0;
 882         int inline_ea = 0;
 883         errcode_t err;
 884         u32 datalen;
 885         u32 block_size = ext2_fs->blocksize;
 886         u32 inode_size = EXT2_INODE_SIZE(ext2_fs->super);
 887         struct ext2_inode_large *ext2_inode;
 888         struct ext2_ext_attr_entry *entry;
 889         void *data;
 890         char *buffer = NULL;
 891         char inode_buf[EXT2_GOOD_OLD_INODE_SIZE];
 892
 893         if (inode_size <= EXT2_GOOD_OLD_INODE_SIZE) {
 894                 ext2_inode = (struct ext2_inode_large *)inode_buf;
 895         } else {
 896                 ext2_inode = (struct ext2_inode_large *)malloc(inode_size);
 897                 if (!ext2_inode)
 898                        return -ENOMEM;
 899         }
 900         err = ext2fs_read_inode_full(ext2_fs, ext2_ino, (void *)ext2_inode,
 901                                      inode_size);
 902         if (err) {
 903                 fprintf(stderr, "ext2fs_read_inode_full: %s\n",
 904                         error_message(err));
 905                 ret = -1;
 906                 goto out;
 907         }
 908
 909         if (ext2_ino > ext2_fs->super->s_first_ino &&
 910             inode_size > EXT2_GOOD_OLD_INODE_SIZE) {
 911                 if (EXT2_GOOD_OLD_INODE_SIZE +
 912                     ext2_inode->i_extra_isize > inode_size) {
 913                         ret = -EIO;
 914                         goto out;
 915                 }
 916                 if (ext2_inode->i_extra_isize != 0 &&
 917                     EXT2_XATTR_IHDR(ext2_inode)->h_magic ==
 918                     EXT2_EXT_ATTR_MAGIC) {
 919                         inline_ea = 1;
 920                 }
 921         }
 922         if (inline_ea) {
 923                 int total;
 924                 void *end = (void *)ext2_inode + inode_size;
 925                 entry = EXT2_XATTR_IFIRST(ext2_inode);
 926                 total = end - (void *)entry;
 927                 ret = ext2_xattr_check_names(entry, end);
 928                 if (ret)
 929                         goto out;
 930                 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
 931                         ret = ext2_xattr_check_entry(entry, total);
 932                         if (ret)
 933                                 goto out;
 934                         data = (void *)EXT2_XATTR_IFIRST(ext2_inode) +
 935                                 entry->e_value_offs;
 936                         datalen = entry->e_value_size;
 937                         ret = copy_single_xattr(trans, root, objectid,
 938                                                 entry, data, datalen);
 939                         if (ret)
 940                                 goto out;
 941                         entry = EXT2_EXT_ATTR_NEXT(entry);
 942                 }
 943         }
 944
 945         if (ext2_inode->i_file_acl == 0)
 946                 goto out;
 947
 948         buffer = malloc(block_size);
 949         if (!buffer) {
 950                 ret = -ENOMEM;
 951                 goto out;
 952         }
 953         err = ext2fs_read_ext_attr(ext2_fs, ext2_inode->i_file_acl, buffer);
 954         if (err) {
 955                 fprintf(stderr, "ext2fs_read_ext_attr: %s\n",
 956                         error_message(err));
 957                 ret = -1;
 958                 goto out;
 959         }
 960         ret = ext2_xattr_check_block(buffer, block_size);
 961         if (ret)
 962                 goto out;
 963
 964         entry = EXT2_XATTR_BFIRST(buffer);
 965         while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
 966                 ret = ext2_xattr_check_entry(entry, block_size);
 967                 if (ret)
 968                         goto out;
 969                 data = buffer + entry->e_value_offs;
 970                 datalen = entry->e_value_size;
 971                 ret = copy_single_xattr(trans, root, objectid,
 972                                         entry, data, datalen);
 973                 if (ret)
 974                         goto out;
 975                 entry = EXT2_EXT_ATTR_NEXT(entry);
 976         }
 977 out:
 978         if (buffer != NULL)
 979                 free(buffer);
 980         if ((void *)ext2_inode != inode_buf)
 981                 free(ext2_inode);
 982         return ret;
 983 }
 984 #define MINORBITS       20
 985 #define MKDEV(ma, mi)   (((ma) << MINORBITS) | (mi))
 986
 987 static inline dev_t old_decode_dev(u16 val)
 988 {
 989         return MKDEV((val >> 8) & 255, val & 255);
 990 }
 991
 992 static inline dev_t new_decode_dev(u32 dev)
 993 {
 994         unsigned major = (dev & 0xfff00) >> 8;
 995         unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);
 996         return MKDEV(major, minor);
 997 }
 998
 999 static int copy_inode_item(struct btrfs_inode_item *dst,
1000                            struct ext2_inode *src, u32 blocksize)
1001 {
1002         btrfs_set_stack_inode_generation(dst, 1);
1003         btrfs_set_stack_inode_size(dst, src->i_size);
1004         btrfs_set_stack_inode_nbytes(dst, 0);
1005         btrfs_set_stack_inode_block_group(dst, 0);
1006         btrfs_set_stack_inode_nlink(dst, src->i_links_count);
1007         btrfs_set_stack_inode_uid(dst, src->i_uid | (src->i_uid_high << 16));
1008         btrfs_set_stack_inode_gid(dst, src->i_gid | (src->i_gid_high << 16));
1009         btrfs_set_stack_inode_mode(dst, src->i_mode);
1010         btrfs_set_stack_inode_rdev(dst, 0);
1011         btrfs_set_stack_inode_flags(dst, 0);
1012         btrfs_set_stack_timespec_sec(&dst->atime, src->i_atime);
1013         btrfs_set_stack_timespec_nsec(&dst->atime, 0);
1014         btrfs_set_stack_timespec_sec(&dst->ctime, src->i_ctime);
1015         btrfs_set_stack_timespec_nsec(&dst->ctime, 0);
1016         btrfs_set_stack_timespec_sec(&dst->mtime, src->i_mtime);
1017         btrfs_set_stack_timespec_nsec(&dst->mtime, 0);
1018         btrfs_set_stack_timespec_sec(&dst->otime, 0);
1019         btrfs_set_stack_timespec_nsec(&dst->otime, 0);
1020
1021         if (S_ISDIR(src->i_mode)) {
1022                 btrfs_set_stack_inode_size(dst, 0);
1023                 btrfs_set_stack_inode_nlink(dst, 1);
1024         }
1025         if (S_ISREG(src->i_mode)) {
1026                 btrfs_set_stack_inode_size(dst, (u64)src->i_size_high << 32 |
1027                                            (u64)src->i_size);
1028         }
1029         if (!S_ISREG(src->i_mode) && !S_ISDIR(src->i_mode) &&
1030             !S_ISLNK(src->i_mode)) {
1031                 if (src->i_block[0]) {
1032                         btrfs_set_stack_inode_rdev(dst,
1033                                 old_decode_dev(src->i_block[0]));
1034                 } else {
1035                         btrfs_set_stack_inode_rdev(dst,
1036                                 new_decode_dev(src->i_block[1]));
1037                 }
1038         }
1039         return 0;
1040 }
1041
1042 /*
1043  * copy a single inode. do all the required works, such as cloning
1044  * inode item, creating file extents and creating directory entries.
1045  */
1046 static int copy_single_inode(struct btrfs_trans_handle *trans,
1047                              struct btrfs_root *root, u64 objectid,
1048                              ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
1049                              struct ext2_inode *ext2_inode,
1050                              int datacsum, int packing, int noxattr)
1051 {
1052         int ret;
1053         struct btrfs_key inode_key;
1054         struct btrfs_inode_item btrfs_inode;
1055
1056         if (ext2_inode->i_links_count == 0)
1057                 return 0;
1058
1059         copy_inode_item(&btrfs_inode, ext2_inode, ext2_fs->blocksize);
1060         if (!datacsum && S_ISREG(ext2_inode->i_mode)) {
1061                 u32 flags = btrfs_stack_inode_flags(&btrfs_inode) |
1062                             BTRFS_INODE_NODATASUM;
1063                 btrfs_set_stack_inode_flags(&btrfs_inode, flags);
1064         }
1065
1066         switch (ext2_inode->i_mode & S_IFMT) {
1067         case S_IFREG:
1068                 ret = create_file_extents(trans, root, objectid, &btrfs_inode,
1069                                         ext2_fs, ext2_ino, datacsum, packing);
1070                 break;
1071         case S_IFDIR:
1072                 ret = create_dir_entries(trans, root, objectid, &btrfs_inode,
1073                                          ext2_fs, ext2_ino);
1074                 break;
1075         case S_IFLNK:
1076                 ret = create_symbol_link(trans, root, objectid, &btrfs_inode,
1077                                          ext2_fs, ext2_ino, ext2_inode);
1078                 break;
1079         default:
1080                 ret = 0;
1081                 break;
1082         }
1083         if (ret)
1084                 return ret;
1085
1086         if (!noxattr) {
1087                 ret = copy_extended_attrs(trans, root, objectid, &btrfs_inode,
1088                                           ext2_fs, ext2_ino);
1089                 if (ret)
1090                         return ret;
1091         }
1092         inode_key.objectid = objectid;
1093         inode_key.offset = 0;
1094         btrfs_set_key_type(&inode_key, BTRFS_INODE_ITEM_KEY);
1095         ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
1096         return ret;
1097 }
1098
1099 static int copy_disk_extent(struct btrfs_root *root, u64 dst_bytenr,
1100                             u64 src_bytenr, u32 num_bytes)
1101 {
1102         int ret;
1103         char *buffer;
1104         struct btrfs_fs_devices *fs_devs = root->fs_info->fs_devices;
1105
1106         buffer = malloc(num_bytes);
1107         if (!buffer)
1108                 return -ENOMEM;
1109         ret = pread(fs_devs->latest_bdev, buffer, num_bytes, src_bytenr);
1110         if (ret != num_bytes)
1111                 goto fail;
1112         ret = pwrite(fs_devs->latest_bdev, buffer, num_bytes, dst_bytenr);
1113         if (ret != num_bytes)
1114                 goto fail;
1115         ret = 0;
1116 fail:
1117         free(buffer);
1118         if (ret > 0)
1119                 ret = -1;
1120         return ret;
1121 }
1122 /*
1123  * scan ext2's inode bitmap and copy all used inodes.
1124  */
1125 static int copy_inodes(struct btrfs_root *root, ext2_filsys ext2_fs,
1126                        int datacsum, int packing, int noxattr)
1127 {
1128         int ret;
1129         errcode_t err;
1130         ext2_inode_scan ext2_scan;
1131         struct ext2_inode ext2_inode;
1132         ext2_ino_t ext2_ino;
1133         u64 objectid;
1134         struct btrfs_trans_handle *trans;
1135
1136         trans = btrfs_start_transaction(root, 1);
1137         if (!trans)
1138                 return -ENOMEM;
1139         err = ext2fs_open_inode_scan(ext2_fs, 0, &ext2_scan);
1140         if (err) {
1141                 fprintf(stderr, "ext2fs_open_inode_scan: %s\n", error_message(err));
1142                 return -1;
1143         }
1144         while (!(err = ext2fs_get_next_inode(ext2_scan, &ext2_ino,
1145                                              &ext2_inode))) {
1146                 /* no more inodes */
1147                 if (ext2_ino == 0)
1148                         break;
1149                 /* skip special inode in ext2fs */
1150                 if (ext2_ino < EXT2_GOOD_OLD_FIRST_INO &&
1151                     ext2_ino != EXT2_ROOT_INO)
1152                         continue;
1153                 objectid = ext2_ino + INO_OFFSET;
1154                 ret = copy_single_inode(trans, root,
1155                                         objectid, ext2_fs, ext2_ino,
1156                                         &ext2_inode, datacsum, packing,
1157                                         noxattr);
1158                 if (ret)
1159                         return ret;
1160                 if (trans->blocks_used >= 4096) {
1161                         ret = btrfs_commit_transaction(trans, root);
1162                         BUG_ON(ret);
1163                         trans = btrfs_start_transaction(root, 1);
1164                         BUG_ON(!trans);
1165                 }
1166         }
1167         if (err) {
1168                 fprintf(stderr, "ext2fs_get_next_inode: %s\n", error_message(err));
1169                 return -1;
1170         }
1171         ret = btrfs_commit_transaction(trans, root);
1172         BUG_ON(ret);
1173
1174         return ret;
1175 }
1176
1177 /*
1178  * Construct a range of ext2fs image file.
1179  * scan block allocation bitmap, find all blocks used by the ext2fs
1180  * in this range and create file extents that point to these blocks.
1181  *
1182  * Note: Before calling the function, no file extent points to blocks
1183  *       in this range
1184  */
1185 static int create_image_file_range(struct btrfs_trans_handle *trans,
1186                                    struct btrfs_root *root, u64 objectid,
1187                                    struct btrfs_inode_item *inode,
1188                                    u64 start_byte, u64 end_byte,
1189                                    ext2_filsys ext2_fs)
1190 {
1191         u32 blocksize = ext2_fs->blocksize;
1192         u32 block = start_byte / blocksize;
1193         u32 last_block = (end_byte + blocksize - 1) / blocksize;
1194         int ret = 0;
1195         struct blk_iterate_data data = {
1196                 .trans          = trans,
1197                 .root           = root,
1198                 .inode          = inode,
1199                 .objectid       = objectid,
1200                 .first_block    = block,
1201                 .disk_block     = 0,
1202                 .num_blocks     = 0,
1203                 .boundary       = (u64)-1,
1204                 .checksum       = 0,
1205                 .errcode        = 0,
1206         };
1207         for (; start_byte < end_byte; block++, start_byte += blocksize) {
1208                 if (!ext2fs_fast_test_block_bitmap(ext2_fs->block_map, block))
1209                         continue;
1210                 ret = block_iterate_proc(NULL, block, block, &data);
1211                 if (ret & BLOCK_ABORT) {
1212                         ret = data.errcode;
1213                         goto fail;
1214                 }
1215         }
1216         if (data.num_blocks > 0) {
1217                 ret = record_file_blocks(trans, root, objectid, inode,
1218                                          data.first_block, data.disk_block,
1219                                          data.num_blocks, 0);
1220                 if (ret)
1221                         goto fail;
1222                 data.first_block += data.num_blocks;
1223         }
1224         if (last_block > data.first_block) {
1225                 ret = record_file_blocks(trans, root, objectid, inode,
1226                                          data.first_block, 0, last_block -
1227                                          data.first_block, 0);
1228                 if (ret)
1229                         goto fail;
1230         }
1231 fail:
1232         return ret;
1233 }
1234 /*
1235  * Create the ext2fs image file.
1236  */
1237 static int create_ext2_image(struct btrfs_root *root, ext2_filsys ext2_fs,
1238                              const char *name)
1239 {
1240         int ret;
1241         struct btrfs_key key;
1242         struct btrfs_key location;
1243         struct btrfs_path path;
1244         struct btrfs_inode_item btrfs_inode;
1245         struct btrfs_inode_item *inode_item;
1246         struct extent_buffer *leaf;
1247         struct btrfs_fs_info *fs_info = root->fs_info;
1248         struct btrfs_root *extent_root = fs_info->extent_root;
1249         struct btrfs_trans_handle *trans;
1250         struct btrfs_extent_item *ei;
1251         struct btrfs_extent_inline_ref *iref;
1252         struct btrfs_extent_data_ref *dref;
1253         u64 bytenr;
1254         u64 num_bytes;
1255         u64 objectid;
1256         u64 last_byte;
1257         u64 first_free;
1258         u64 total_bytes;
1259         u32 sectorsize = root->sectorsize;
1260
1261         total_bytes = btrfs_super_total_bytes(&fs_info->super_copy);
1262         first_free =  BTRFS_SUPER_INFO_OFFSET + sectorsize * 2 - 1;
1263         first_free &= ~((u64)sectorsize - 1);
1264
1265         memset(&btrfs_inode, 0, sizeof(btrfs_inode));
1266         btrfs_set_stack_inode_generation(&btrfs_inode, 1);
1267         btrfs_set_stack_inode_size(&btrfs_inode, total_bytes);
1268         btrfs_set_stack_inode_nlink(&btrfs_inode, 1);
1269         btrfs_set_stack_inode_nbytes(&btrfs_inode, 0);
1270         btrfs_set_stack_inode_mode(&btrfs_inode, S_IFREG | 0400);
1271         btrfs_set_stack_inode_flags(&btrfs_inode, BTRFS_INODE_NODATASUM |
1272                                     BTRFS_INODE_READONLY);
1273         btrfs_init_path(&path);
1274         trans = btrfs_start_transaction(root, 1);
1275         BUG_ON(!trans);
1276
1277         objectid = btrfs_root_dirid(&root->root_item);
1278         ret = btrfs_find_free_objectid(trans, root, objectid, &objectid);
1279         if (ret)
1280                 goto fail;
1281
1282         /*
1283          * copy blocks covered by extent #0 to new positions. extent #0 is
1284          * special, we can't rely on relocate_extents_range to relocate it.
1285          */
1286         for (last_byte = 0; last_byte < first_free; last_byte += sectorsize) {
1287                 ret = custom_alloc_extent(root, sectorsize, 0, &key);
1288                 if (ret)
1289                         goto fail;
1290                 ret = copy_disk_extent(root, key.objectid, last_byte,
1291                                        sectorsize);
1292                 if (ret)
1293                         goto fail;
1294                 ret = record_file_extent(trans, root, objectid,
1295                                          &btrfs_inode, last_byte,
1296                                          key.objectid, sectorsize, 0);
1297                 if (ret)
1298                         goto fail;
1299         }
1300
1301         while(1) {
1302                 key.objectid = last_byte;
1303                 key.offset = 0;
1304                 btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
1305                 ret = btrfs_search_slot(trans, fs_info->extent_root,
1306                                         &key, &path, 0, 0);
1307                 if (ret < 0)
1308                         goto fail;
1309 next:
1310                 leaf = path.nodes[0];
1311                 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1312                         ret = btrfs_next_leaf(extent_root, &path);
1313                         if (ret < 0)
1314                                 goto fail;
1315                         if (ret > 0)
1316                                 break;
1317                         leaf = path.nodes[0];
1318                 }
1319                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1320                 if (last_byte > key.objectid ||
1321                     key.type != BTRFS_EXTENT_ITEM_KEY) {
1322                         path.slots[0]++;
1323                         goto next;
1324                 }
1325
1326                 bytenr = key.objectid;
1327                 num_bytes = key.offset;
1328                 ei = btrfs_item_ptr(leaf, path.slots[0],
1329                                     struct btrfs_extent_item);
1330                 if (!(btrfs_extent_flags(leaf, ei) & BTRFS_EXTENT_FLAG_DATA)) {
1331                         path.slots[0]++;
1332                         goto next;
1333                 }
1334
1335                 BUG_ON(btrfs_item_size_nr(leaf, path.slots[0]) != sizeof(*ei) +
1336                        btrfs_extent_inline_ref_size(BTRFS_EXTENT_DATA_REF_KEY));
1337
1338                 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
1339                 key.type = btrfs_extent_inline_ref_type(leaf, iref);
1340                 BUG_ON(key.type != BTRFS_EXTENT_DATA_REF_KEY);
1341                 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1342                 if (btrfs_extent_data_ref_root(leaf, dref) !=
1343                     BTRFS_FS_TREE_OBJECTID) {
1344                         path.slots[0]++;
1345                         goto next;
1346                 }
1347
1348                 if (bytenr > last_byte) {
1349                         ret = create_image_file_range(trans, root, objectid,
1350                                                       &btrfs_inode, last_byte,
1351                                                       bytenr, ext2_fs);
1352                         if (ret)
1353                                 goto fail;
1354                 }
1355                 ret = record_file_extent(trans, root, objectid, &btrfs_inode,
1356                                          bytenr, bytenr, num_bytes, 0);
1357                 if (ret)
1358                         goto fail;
1359                 last_byte = bytenr + num_bytes;
1360                 btrfs_release_path(extent_root, &path);
1361
1362                 if (trans->blocks_used >= 4096) {
1363                         ret = btrfs_commit_transaction(trans, root);
1364                         BUG_ON(ret);
1365                         trans = btrfs_start_transaction(root, 1);
1366                         BUG_ON(!trans);
1367                 }
1368         }
1369         btrfs_release_path(root, &path);
1370         if (total_bytes > last_byte) {
1371                 ret = create_image_file_range(trans, root, objectid,
1372                                               &btrfs_inode, last_byte,
1373                                               total_bytes, ext2_fs);
1374                 if (ret)
1375                         goto fail;
1376         }
1377
1378         ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
1379         if (ret)
1380                 goto fail;
1381
1382         location.objectid = objectid;
1383         location.offset = 0;
1384         btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
1385         ret = btrfs_insert_dir_item(trans, root, name, strlen(name),
1386                                     btrfs_root_dirid(&root->root_item),
1387                                     &location, EXT2_FT_REG_FILE, objectid);
1388         if (ret)
1389                 goto fail;
1390         ret = btrfs_insert_inode_ref(trans, root, name, strlen(name),
1391                                      objectid,
1392                                      btrfs_root_dirid(&root->root_item),
1393                                      objectid);
1394         if (ret)
1395                 goto fail;
1396         location.objectid = btrfs_root_dirid(&root->root_item);
1397         location.offset = 0;
1398         btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
1399         ret = btrfs_lookup_inode(trans, root, &path, &location, 1);
1400         if (ret)
1401                 goto fail;
1402         leaf = path.nodes[0];
1403         inode_item = btrfs_item_ptr(leaf, path.slots[0],
1404                                     struct btrfs_inode_item);
1405         btrfs_set_inode_size(leaf, inode_item, strlen(name) * 2 +
1406                              btrfs_inode_size(leaf, inode_item));
1407         btrfs_mark_buffer_dirty(leaf);
1408         btrfs_release_path(root, &path);
1409         ret = btrfs_commit_transaction(trans, root);
1410         BUG_ON(ret);
1411 fail:
1412         btrfs_release_path(root, &path);
1413         return ret;
1414 }
1415
1416 struct btrfs_root *link_subvol(struct btrfs_root *root, const char *base,
1417                                u64 root_objectid)
1418 {
1419         struct btrfs_trans_handle *trans;
1420         struct btrfs_fs_info *fs_info = root->fs_info;
1421         struct btrfs_root *tree_root = fs_info->tree_root;
1422         struct btrfs_root *new_root = NULL;
1423         struct btrfs_path *path;
1424         struct btrfs_inode_item *inode_item;
1425         struct extent_buffer *leaf;
1426         struct btrfs_key key;
1427         u64 dirid = btrfs_root_dirid(&root->root_item);
1428         u64 index = 2;
1429         char buf[64];
1430         int i;
1431         int ret;
1432
1433         path = btrfs_alloc_path();
1434         BUG_ON(!path);
1435
1436         key.objectid = dirid;
1437         key.type = BTRFS_DIR_INDEX_KEY;
1438         key.offset = (u64)-1;
1439
1440         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1441         BUG_ON(ret <= 0);
1442
1443         if (path->slots[0] > 0) {
1444                 path->slots[0]--;
1445                 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1446                 if (key.objectid == dirid && key.type == BTRFS_DIR_INDEX_KEY)
1447                         index = key.offset + 1;
1448         }
1449         btrfs_release_path(root, path);
1450
1451         trans = btrfs_start_transaction(root, 1);
1452         BUG_ON(!trans);
1453
1454         key.objectid = dirid;
1455         key.offset = 0;
1456         key.type =  BTRFS_INODE_ITEM_KEY;
1457
1458         ret = btrfs_lookup_inode(trans, root, path, &key, 1);
1459         BUG_ON(ret);
1460         leaf = path->nodes[0];
1461         inode_item = btrfs_item_ptr(leaf, path->slots[0],
1462                                     struct btrfs_inode_item);
1463
1464         key.objectid = root_objectid;
1465         key.offset = (u64)-1;
1466         key.type = BTRFS_ROOT_ITEM_KEY;
1467
1468         strcpy(buf, base);
1469         for (i = 0; i < 1024; i++) {
1470                 ret = btrfs_insert_dir_item(trans, root, buf, strlen(buf),
1471                                             dirid, &key, BTRFS_FT_DIR, index);
1472                 if (ret != -EEXIST)
1473                         break;
1474                 sprintf(buf, "%s%d", base, i);
1475         }
1476         if (ret)
1477                 goto fail;
1478
1479         btrfs_set_inode_size(leaf, inode_item, strlen(buf) * 2 +
1480                              btrfs_inode_size(leaf, inode_item));
1481         btrfs_mark_buffer_dirty(leaf);
1482         btrfs_release_path(root, path);
1483
1484         /* add the backref first */
1485         ret = btrfs_add_root_ref(trans, tree_root, root_objectid,
1486                                  BTRFS_ROOT_BACKREF_KEY,
1487                                  root->root_key.objectid,
1488                                  dirid, index, buf, strlen(buf));
1489         BUG_ON(ret);
1490
1491         /* now add the forward ref */
1492         ret = btrfs_add_root_ref(trans, tree_root, root->root_key.objectid,
1493                                  BTRFS_ROOT_REF_KEY, root_objectid,
1494                                  dirid, index, buf, strlen(buf));
1495
1496         ret = btrfs_commit_transaction(trans, root);
1497         BUG_ON(ret);
1498
1499         new_root = btrfs_read_fs_root(fs_info, &key);
1500         if (IS_ERR(new_root))
1501                 new_root = NULL;
1502 fail:
1503         btrfs_free_path(path);
1504         return new_root;
1505 }
1506
1507 static int create_chunk_mapping(struct btrfs_trans_handle *trans,
1508                                 struct btrfs_root *root)
1509 {
1510         struct btrfs_fs_info *info = root->fs_info;
1511         struct btrfs_root *chunk_root = info->chunk_root;
1512         struct btrfs_root *extent_root = info->extent_root;
1513         struct btrfs_device *device;
1514         struct btrfs_block_group_cache *cache;
1515         struct btrfs_dev_extent *extent;
1516         struct extent_buffer *leaf;
1517         struct btrfs_chunk chunk;
1518         struct btrfs_key key;
1519         struct btrfs_path path;
1520         u64 cur_start;
1521         u64 total_bytes;
1522         u64 chunk_objectid;
1523         int ret;
1524
1525         btrfs_init_path(&path);
1526
1527         total_bytes = btrfs_super_total_bytes(&root->fs_info->super_copy);
1528         chunk_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
1529
1530         BUG_ON(list_empty(&info->fs_devices->devices));
1531         device = list_entry(info->fs_devices->devices.next,
1532                             struct btrfs_device, dev_list);
1533         BUG_ON(device->devid != info->fs_devices->latest_devid);
1534
1535         /* delete device extent created by make_btrfs */
1536         key.objectid = device->devid;
1537         key.offset = 0;
1538         key.type = BTRFS_DEV_EXTENT_KEY;
1539         ret = btrfs_search_slot(trans, device->dev_root, &key, &path, -1, 1);
1540         if (ret < 0)
1541                 goto err;
1542
1543         BUG_ON(ret > 0);
1544         ret = btrfs_del_item(trans, device->dev_root, &path);
1545         if (ret)
1546                 goto err;
1547         btrfs_release_path(device->dev_root, &path);
1548
1549         /* delete chunk item created by make_btrfs */
1550         key.objectid = chunk_objectid;
1551         key.offset = 0;
1552         key.type = BTRFS_CHUNK_ITEM_KEY;
1553         ret = btrfs_search_slot(trans, chunk_root, &key, &path, -1, 1);
1554         if (ret < 0)
1555                 goto err;
1556
1557         BUG_ON(ret > 0);
1558         ret = btrfs_del_item(trans, chunk_root, &path);
1559         if (ret)
1560                 goto err;
1561         btrfs_release_path(chunk_root, &path);
1562
1563         /* for each block group, create device extent and chunk item */
1564         cur_start = 0;
1565         while (cur_start < total_bytes) {
1566                 cache = btrfs_lookup_block_group(root->fs_info, cur_start);
1567                 BUG_ON(!cache);
1568
1569                 /* insert device extent */
1570                 key.objectid = device->devid;
1571                 key.offset = cache->key.objectid;
1572                 key.type = BTRFS_DEV_EXTENT_KEY;
1573                 ret = btrfs_insert_empty_item(trans, device->dev_root, &path,
1574                                               &key, sizeof(*extent));
1575                 if (ret)
1576                         goto err;
1577
1578                 leaf = path.nodes[0];
1579                 extent = btrfs_item_ptr(leaf, path.slots[0],
1580                                         struct btrfs_dev_extent);
1581
1582                 btrfs_set_dev_extent_chunk_tree(leaf, extent,
1583                                                 chunk_root->root_key.objectid);
1584                 btrfs_set_dev_extent_chunk_objectid(leaf, extent,
1585                                                     chunk_objectid);
1586                 btrfs_set_dev_extent_chunk_offset(leaf, extent,
1587                                                   cache->key.objectid);
1588                 btrfs_set_dev_extent_length(leaf, extent, cache->key.offset);
1589                 write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid,
1590                     (unsigned long)btrfs_dev_extent_chunk_tree_uuid(extent),
1591                     BTRFS_UUID_SIZE);
1592                 btrfs_mark_buffer_dirty(leaf);
1593                 btrfs_release_path(device->dev_root, &path);
1594
1595                 /* insert chunk item */
1596                 btrfs_set_stack_chunk_length(&chunk, cache->key.offset);
1597                 btrfs_set_stack_chunk_owner(&chunk,
1598                                             extent_root->root_key.objectid);
1599                 btrfs_set_stack_chunk_stripe_len(&chunk, STRIPE_LEN);
1600                 btrfs_set_stack_chunk_type(&chunk, cache->flags);
1601                 btrfs_set_stack_chunk_io_align(&chunk, device->io_align);
1602                 btrfs_set_stack_chunk_io_width(&chunk, device->io_width);
1603                 btrfs_set_stack_chunk_sector_size(&chunk, device->sector_size);
1604                 btrfs_set_stack_chunk_num_stripes(&chunk, 1);
1605                 btrfs_set_stack_chunk_sub_stripes(&chunk, 0);
1606                 btrfs_set_stack_stripe_devid(&chunk.stripe, device->devid);
1607                 btrfs_set_stack_stripe_offset(&chunk.stripe,
1608                                               cache->key.objectid);
1609                 memcpy(&chunk.stripe.dev_uuid, device->uuid, BTRFS_UUID_SIZE);
1610
1611                 key.objectid = chunk_objectid;
1612                 key.offset = cache->key.objectid;
1613                 key.type = BTRFS_CHUNK_ITEM_KEY;
1614
1615                 ret = btrfs_insert_item(trans, chunk_root, &key, &chunk,
1616                                         btrfs_chunk_item_size(1));
1617                 if (ret)
1618                         goto err;
1619
1620                 cur_start = cache->key.objectid + cache->key.offset;
1621         }
1622
1623         device->bytes_used = total_bytes;
1624         ret = btrfs_update_device(trans, device);
1625 err:
1626         btrfs_release_path(device->dev_root, &path);
1627         return ret;
1628 }
1629
1630 static int create_subvol(struct btrfs_trans_handle *trans,
1631                          struct btrfs_root *root, u64 root_objectid)
1632 {
1633         struct extent_buffer *tmp;
1634         struct btrfs_root *new_root;
1635         struct btrfs_key key;
1636         struct btrfs_root_item root_item;
1637         int ret;
1638
1639         ret = btrfs_copy_root(trans, root, root->node, &tmp,
1640                               root_objectid);
1641         BUG_ON(ret);
1642
1643         memcpy(&root_item, &root->root_item, sizeof(root_item));
1644         btrfs_set_root_bytenr(&root_item, tmp->start);
1645         btrfs_set_root_level(&root_item, btrfs_header_level(tmp));
1646         btrfs_set_root_generation(&root_item, trans->transid);
1647         free_extent_buffer(tmp);
1648
1649         key.objectid = root_objectid;
1650         key.type = BTRFS_ROOT_ITEM_KEY;
1651         key.offset = trans->transid;
1652         ret = btrfs_insert_root(trans, root->fs_info->tree_root,
1653                                 &key, &root_item);
1654
1655         key.offset = (u64)-1;
1656         new_root = btrfs_read_fs_root(root->fs_info, &key);
1657         BUG_ON(!new_root || IS_ERR(new_root));
1658
1659         ret = btrfs_make_root_dir(trans, new_root, BTRFS_FIRST_FREE_OBJECTID);
1660         BUG_ON(ret);
1661
1662         return 0;
1663 }
1664
1665 static int init_btrfs(struct btrfs_root *root)
1666 {
1667         int ret;
1668         struct btrfs_key location;
1669         struct btrfs_trans_handle *trans;
1670         struct btrfs_fs_info *fs_info = root->fs_info;
1671         struct extent_buffer *tmp;
1672
1673         trans = btrfs_start_transaction(root, 1);
1674         BUG_ON(!trans);
1675         ret = btrfs_make_block_groups(trans, root);
1676         if (ret)
1677                 goto err;
1678         ret = btrfs_fixup_block_accounting(trans, root);
1679         if (ret)
1680                 goto err;
1681         ret = create_chunk_mapping(trans, root);
1682         if (ret)
1683                 goto err;
1684         ret = btrfs_make_root_dir(trans, fs_info->tree_root,
1685                                   BTRFS_ROOT_TREE_DIR_OBJECTID);
1686         if (ret)
1687                 goto err;
1688         memcpy(&location, &root->root_key, sizeof(location));
1689         location.offset = (u64)-1;
1690         ret = btrfs_insert_dir_item(trans, fs_info->tree_root, "default", 7,
1691                                 btrfs_super_root_dir(&fs_info->super_copy),
1692                                 &location, BTRFS_FT_DIR, 0);
1693         if (ret)
1694                 goto err;
1695         ret = btrfs_insert_inode_ref(trans, fs_info->tree_root, "default", 7,
1696                                 location.objectid,
1697                                 btrfs_super_root_dir(&fs_info->super_copy), 0);
1698         if (ret)
1699                 goto err;
1700         btrfs_set_root_dirid(&fs_info->fs_root->root_item,
1701                              BTRFS_FIRST_FREE_OBJECTID);
1702
1703         /* subvol for ext2 image file */
1704         ret = create_subvol(trans, root, EXT2_IMAGE_SUBVOL_OBJECTID);
1705         BUG_ON(ret);
1706         /* subvol for data relocation */
1707         ret = create_subvol(trans, root, BTRFS_DATA_RELOC_TREE_OBJECTID);
1708         BUG_ON(ret);
1709
1710         ret = __btrfs_cow_block(trans, fs_info->csum_root,
1711                                 fs_info->csum_root->node, NULL, 0, &tmp, 0, 0);
1712         BUG_ON(ret);
1713         free_extent_buffer(tmp);
1714
1715         ret = btrfs_commit_transaction(trans, root);
1716         BUG_ON(ret);
1717 err:
1718         return ret;
1719 }
1720
1721 /*
1722  * Migrate super block to it's default position and zero 0 ~ 16k
1723  */
1724 static int migrate_super_block(int fd, u64 old_bytenr, u32 sectorsize)
1725 {
1726         int ret;
1727         struct extent_buffer *buf;
1728         struct btrfs_super_block *super;
1729         u32 len;
1730         u32 bytenr;
1731
1732         BUG_ON(sectorsize < sizeof(*super));
1733         buf = malloc(sizeof(*buf) + sectorsize);
1734         if (!buf)
1735                 return -ENOMEM;
1736
1737         buf->len = sectorsize;
1738         ret = pread(fd, buf->data, sectorsize, old_bytenr);
1739         if (ret != sectorsize)
1740                 goto fail;
1741
1742         super = (struct btrfs_super_block *)buf->data;
1743         BUG_ON(btrfs_super_bytenr(super) != old_bytenr);
1744         btrfs_set_super_bytenr(super, BTRFS_SUPER_INFO_OFFSET);
1745
1746         csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
1747         ret = pwrite(fd, buf->data, sectorsize, BTRFS_SUPER_INFO_OFFSET);
1748         if (ret != sectorsize)
1749                 goto fail;
1750
1751         ret = fsync(fd);
1752         if (ret)
1753                 goto fail;
1754
1755         memset(buf->data, 0, sectorsize);
1756         for (bytenr = 0; bytenr < BTRFS_SUPER_INFO_OFFSET; ) {
1757                 len = BTRFS_SUPER_INFO_OFFSET - bytenr;
1758                 if (len > sectorsize)
1759                         len = sectorsize;
1760                 ret = pwrite(fd, buf->data, len, bytenr);
1761                 if (ret != len) {
1762                         fprintf(stderr, "unable to zero fill device\n");
1763                         break;
1764                 }
1765                 bytenr += len;
1766         }
1767         ret = 0;
1768         fsync(fd);
1769 fail:
1770         free(buf);
1771         if (ret > 0)
1772                 ret = -1;
1773         return ret;
1774 }
1775
1776 static int prepare_system_chunk_sb(struct btrfs_super_block *super)
1777 {
1778         struct btrfs_chunk *chunk;
1779         struct btrfs_disk_key *key;
1780         u32 sectorsize = btrfs_super_sectorsize(super);
1781
1782         key = (struct btrfs_disk_key *)(super->sys_chunk_array);
1783         chunk = (struct btrfs_chunk *)(super->sys_chunk_array +
1784                                        sizeof(struct btrfs_disk_key));
1785
1786         btrfs_set_disk_key_objectid(key, BTRFS_FIRST_CHUNK_TREE_OBJECTID);
1787         btrfs_set_disk_key_type(key, BTRFS_CHUNK_ITEM_KEY);
1788         btrfs_set_disk_key_offset(key, 0);
1789
1790         btrfs_set_stack_chunk_length(chunk, btrfs_super_total_bytes(super));
1791         btrfs_set_stack_chunk_owner(chunk, BTRFS_EXTENT_TREE_OBJECTID);
1792         btrfs_set_stack_chunk_stripe_len(chunk, 64 * 1024);
1793         btrfs_set_stack_chunk_type(chunk, BTRFS_BLOCK_GROUP_SYSTEM);
1794         btrfs_set_stack_chunk_io_align(chunk, sectorsize);
1795         btrfs_set_stack_chunk_io_width(chunk, sectorsize);
1796         btrfs_set_stack_chunk_sector_size(chunk, sectorsize);
1797         btrfs_set_stack_chunk_num_stripes(chunk, 1);
1798         btrfs_set_stack_chunk_sub_stripes(chunk, 0);
1799         chunk->stripe.devid = super->dev_item.devid;
1800         chunk->stripe.offset = cpu_to_le64(0);
1801         memcpy(chunk->stripe.dev_uuid, super->dev_item.uuid, BTRFS_UUID_SIZE);
1802         btrfs_set_super_sys_array_size(super, sizeof(*key) + sizeof(*chunk));
1803         return 0;
1804 }
1805
1806 static int prepare_system_chunk(int fd, u64 sb_bytenr, u32 sectorsize)
1807 {
1808         int ret;
1809         struct extent_buffer *buf;
1810         struct btrfs_super_block *super;
1811
1812         BUG_ON(sectorsize < sizeof(*super));
1813         buf = malloc(sizeof(*buf) + sectorsize);
1814         if (!buf)
1815                 return -ENOMEM;
1816
1817         buf->len = sectorsize;
1818         ret = pread(fd, buf->data, sectorsize, sb_bytenr);
1819         if (ret != sectorsize)
1820                 goto fail;
1821
1822         super = (struct btrfs_super_block *)buf->data;
1823         BUG_ON(btrfs_super_bytenr(super) != sb_bytenr);
1824         BUG_ON(btrfs_super_num_devices(super) != 1);
1825
1826         ret = prepare_system_chunk_sb(super);
1827         if (ret)
1828                 goto fail;
1829
1830         csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
1831         ret = pwrite(fd, buf->data, sectorsize, sb_bytenr);
1832         if (ret != sectorsize)
1833                 goto fail;
1834
1835         ret = 0;
1836 fail:
1837         free(buf);
1838         if (ret > 0)
1839                 ret = -1;
1840         return ret;
1841 }
1842
1843 static int relocate_one_reference(struct btrfs_trans_handle *trans,
1844                                   struct btrfs_root *root,
1845                                   u64 extent_start, u64 extent_size,
1846                                   struct btrfs_key *extent_key,
1847                                   struct extent_io_tree *reloc_tree)
1848 {
1849         struct extent_buffer *leaf;
1850         struct btrfs_file_extent_item *fi;
1851         struct btrfs_key key;
1852         struct btrfs_path path;
1853         struct btrfs_inode_item inode;
1854         struct blk_iterate_data data;
1855         u64 bytenr;
1856         u64 num_bytes;
1857         u64 cur_offset;
1858         u64 new_pos;
1859         u64 nbytes;
1860         u64 sector_end;
1861         u32 sectorsize = root->sectorsize;
1862         unsigned long ptr;
1863         int datacsum;
1864         int fd;
1865         int ret;
1866
1867         btrfs_init_path(&path);
1868         ret = btrfs_search_slot(trans, root, extent_key, &path, -1, 1);
1869         if (ret)
1870                 goto fail;
1871
1872         leaf = path.nodes[0];
1873         fi = btrfs_item_ptr(leaf, path.slots[0],
1874                             struct btrfs_file_extent_item);
1875         BUG_ON(btrfs_file_extent_offset(leaf, fi) > 0);
1876         if (extent_start != btrfs_file_extent_disk_bytenr(leaf, fi) ||
1877             extent_size != btrfs_file_extent_disk_num_bytes(leaf, fi)) {
1878                 ret = 1;
1879                 goto fail;
1880         }
1881
1882         bytenr = extent_start + btrfs_file_extent_offset(leaf, fi);
1883         num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
1884
1885         ret = btrfs_del_item(trans, root, &path);
1886         if (ret)
1887                 goto fail;
1888
1889         ret = btrfs_free_extent(trans, root, extent_start, extent_size, 0,
1890                                 root->root_key.objectid,
1891                                 extent_key->objectid, extent_key->offset);
1892         if (ret)
1893                 goto fail;
1894
1895         btrfs_release_path(root, &path);
1896
1897         key.objectid = extent_key->objectid;
1898         key.offset = 0;
1899         key.type =  BTRFS_INODE_ITEM_KEY;
1900         ret = btrfs_lookup_inode(trans, root, &path, &key, 0);
1901         if (ret)
1902                 goto fail;
1903
1904         leaf = path.nodes[0];
1905         ptr = btrfs_item_ptr_offset(leaf, path.slots[0]);
1906         read_extent_buffer(leaf, &inode, ptr, sizeof(inode));
1907         btrfs_release_path(root, &path);
1908
1909         BUG_ON(num_bytes & (sectorsize - 1));
1910         nbytes = btrfs_stack_inode_nbytes(&inode) - num_bytes;
1911         btrfs_set_stack_inode_nbytes(&inode, nbytes);
1912         datacsum = !(btrfs_stack_inode_flags(&inode) & BTRFS_INODE_NODATASUM);
1913
1914         data = (struct blk_iterate_data) {
1915                 .trans          = trans,
1916                 .root           = root,
1917                 .inode          = &inode,
1918                 .objectid       = extent_key->objectid,
1919                 .first_block    = extent_key->offset / sectorsize,
1920                 .disk_block     = 0,
1921                 .num_blocks     = 0,
1922                 .boundary       = (u64)-1,
1923                 .checksum       = datacsum,
1924                 .errcode        = 0,
1925         };
1926
1927         cur_offset = extent_key->offset;
1928         while (num_bytes > 0) {
1929                 sector_end = bytenr + sectorsize - 1;
1930                 if (test_range_bit(reloc_tree, bytenr, sector_end,
1931                                    EXTENT_LOCKED, 1)) {
1932                         ret = get_state_private(reloc_tree, bytenr, &new_pos);
1933                         BUG_ON(ret);
1934                 } else {
1935                         ret = custom_alloc_extent(root, sectorsize, 0, &key);
1936                         if (ret)
1937                                 goto fail;
1938                         new_pos = key.objectid;
1939
1940                         if (cur_offset == extent_key->offset) {
1941                                 fd = root->fs_info->fs_devices->latest_bdev;
1942                                 readahead(fd, bytenr, num_bytes);
1943                         }
1944                         ret = copy_disk_extent(root, new_pos, bytenr,
1945                                                sectorsize);
1946                         if (ret)
1947                                 goto fail;
1948                         ret = set_extent_bits(reloc_tree, bytenr, sector_end,
1949                                               EXTENT_LOCKED, GFP_NOFS);
1950                         BUG_ON(ret);
1951                         ret = set_state_private(reloc_tree, bytenr, new_pos);
1952                         BUG_ON(ret);
1953                 }
1954
1955                 ret = block_iterate_proc(NULL, new_pos / sectorsize,
1956                                          cur_offset / sectorsize, &data);
1957                 if (ret & BLOCK_ABORT) {
1958                         ret = data.errcode;
1959                         goto fail;
1960                 }
1961
1962                 cur_offset += sectorsize;
1963                 bytenr += sectorsize;
1964                 num_bytes -= sectorsize;
1965         }
1966
1967         if (data.num_blocks > 0) {
1968                 ret = record_file_blocks(trans, root,
1969                                          extent_key->objectid, &inode,
1970                                          data.first_block, data.disk_block,
1971                                          data.num_blocks, datacsum);
1972                 if (ret)
1973                         goto fail;
1974         }
1975
1976         key.objectid = extent_key->objectid;
1977         key.offset = 0;
1978         key.type =  BTRFS_INODE_ITEM_KEY;
1979         ret = btrfs_lookup_inode(trans, root, &path, &key, 1);
1980         if (ret)
1981                 goto fail;
1982
1983         leaf = path.nodes[0];
1984         ptr = btrfs_item_ptr_offset(leaf, path.slots[0]);
1985         write_extent_buffer(leaf, &inode, ptr, sizeof(inode));
1986         btrfs_mark_buffer_dirty(leaf);
1987         btrfs_release_path(root, &path);
1988
1989 fail:
1990         btrfs_release_path(root, &path);
1991         return ret;
1992 }
1993
1994 static int relocate_extents_range(struct btrfs_root *fs_root,
1995                                   struct btrfs_root *ext2_root,
1996                                   u64 start_byte, u64 end_byte)
1997 {
1998         struct btrfs_fs_info *info = fs_root->fs_info;
1999         struct btrfs_root *extent_root = info->extent_root;
2000         struct btrfs_root *cur_root = NULL;
2001         struct btrfs_trans_handle *trans;
2002         struct btrfs_extent_data_ref *dref;
2003         struct btrfs_extent_inline_ref *iref;
2004         struct btrfs_extent_item *ei;
2005         struct extent_buffer *leaf;
2006         struct btrfs_key key;
2007         struct btrfs_key extent_key;
2008         struct btrfs_path path;
2009         struct extent_io_tree reloc_tree;
2010         unsigned long ptr;
2011         unsigned long end;
2012         u64 cur_byte;
2013         u64 num_bytes;
2014         u64 ref_root;
2015         u64 num_extents;
2016         int pass = 0;
2017         int ret;
2018
2019         btrfs_init_path(&path);
2020         extent_io_tree_init(&reloc_tree);
2021
2022         key.objectid = start_byte;
2023         key.offset = 0;
2024         key.type = BTRFS_EXTENT_ITEM_KEY;
2025         ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
2026         if (ret < 0)
2027                 goto fail;
2028         if (ret > 0) {
2029                 ret = btrfs_previous_item(extent_root, &path, 0,
2030                                           BTRFS_EXTENT_ITEM_KEY);
2031                 if (ret < 0)
2032                         goto fail;
2033                 if (ret == 0) {
2034                         leaf = path.nodes[0];
2035                         btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
2036                         if (key.objectid + key.offset > start_byte)
2037                                 start_byte = key.objectid;
2038                 }
2039         }
2040         btrfs_release_path(extent_root, &path);
2041 again:
2042         cur_root = (pass % 2 == 0) ? ext2_root : fs_root;
2043         num_extents = 0;
2044
2045         trans = btrfs_start_transaction(cur_root, 1);
2046         BUG_ON(!trans);
2047
2048         cur_byte = start_byte;
2049         while (1) {
2050                 key.objectid = cur_byte;
2051                 key.offset = 0;
2052                 key.type = BTRFS_EXTENT_ITEM_KEY;
2053                 ret = btrfs_search_slot(trans, extent_root,
2054                                         &key, &path, 0, 0);
2055                 if (ret < 0)
2056                         goto fail;
2057 next:
2058                 leaf = path.nodes[0];
2059                 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
2060                         ret = btrfs_next_leaf(extent_root, &path);
2061                         if (ret < 0)
2062                                 goto fail;
2063                         if (ret > 0)
2064                                 break;
2065                         leaf = path.nodes[0];
2066                 }
2067
2068                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
2069                 if (key.objectid < cur_byte ||
2070                     key.type != BTRFS_EXTENT_ITEM_KEY) {
2071                         path.slots[0]++;
2072                         goto next;
2073                 }
2074                 if (key.objectid >= end_byte)
2075                         break;
2076
2077                 num_extents++;
2078
2079                 cur_byte = key.objectid;
2080                 num_bytes = key.offset;
2081                 ei = btrfs_item_ptr(leaf, path.slots[0],
2082                                     struct btrfs_extent_item);
2083                 BUG_ON(!(btrfs_extent_flags(leaf, ei) &
2084                          BTRFS_EXTENT_FLAG_DATA));
2085
2086                 ptr = btrfs_item_ptr_offset(leaf, path.slots[0]);
2087                 end = ptr + btrfs_item_size_nr(leaf, path.slots[0]);
2088
2089                 ptr += sizeof(struct btrfs_extent_item);
2090
2091                 while (ptr < end) {
2092                         iref = (struct btrfs_extent_inline_ref *)ptr;
2093                         key.type = btrfs_extent_inline_ref_type(leaf, iref);
2094                         BUG_ON(key.type != BTRFS_EXTENT_DATA_REF_KEY);
2095                         dref = (struct btrfs_extent_data_ref *)(&iref->offset);
2096                         ref_root = btrfs_extent_data_ref_root(leaf, dref);
2097                         extent_key.objectid =
2098                                 btrfs_extent_data_ref_objectid(leaf, dref);
2099                         extent_key.offset =
2100                                 btrfs_extent_data_ref_offset(leaf, dref);
2101                         extent_key.type = BTRFS_EXTENT_DATA_KEY;
2102                         BUG_ON(btrfs_extent_data_ref_count(leaf, dref) != 1);
2103
2104                         if (ref_root == cur_root->root_key.objectid)
2105                                 break;
2106
2107                         ptr += btrfs_extent_inline_ref_size(key.type);
2108                 }
2109
2110                 if (ptr >= end) {
2111                         path.slots[0]++;
2112                         goto next;
2113                 }
2114
2115                 ret = relocate_one_reference(trans, cur_root, cur_byte,
2116                                              num_bytes, &extent_key,
2117                                              &reloc_tree);
2118                 if (ret < 0)
2119                         goto fail;
2120
2121                 cur_byte += num_bytes;
2122                 btrfs_release_path(extent_root, &path);
2123
2124                 if (trans->blocks_used >= 4096) {
2125                         ret = btrfs_commit_transaction(trans, cur_root);
2126                         BUG_ON(ret);
2127                         trans = btrfs_start_transaction(cur_root, 1);
2128                         BUG_ON(!trans);
2129                 }
2130         }
2131         btrfs_release_path(cur_root, &path);
2132
2133         ret = btrfs_commit_transaction(trans, cur_root);
2134         BUG_ON(ret);
2135
2136         if (num_extents > 0 && pass++ < 16)
2137                 goto again;
2138
2139         ret = (num_extents > 0) ? -1 : 0;
2140 fail:
2141         btrfs_release_path(cur_root, &path);
2142         extent_io_tree_cleanup(&reloc_tree);
2143         return ret;
2144 }
2145
2146 /*
2147  * relocate data in system chunk
2148  */
2149 static int cleanup_sys_chunk(struct btrfs_root *fs_root,
2150                              struct btrfs_root *ext2_root)
2151 {
2152         struct btrfs_block_group_cache *cache;
2153         int i, ret = 0;
2154         u64 offset = 0;
2155         u64 end_byte;
2156
2157         while(1) {
2158                 cache = btrfs_lookup_block_group(fs_root->fs_info, offset);
2159                 if (!cache)
2160                         break;
2161
2162                 end_byte = cache->key.objectid + cache->key.offset;
2163                 if (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM) {
2164                         ret = relocate_extents_range(fs_root, ext2_root,
2165                                                      cache->key.objectid,
2166                                                      end_byte);
2167                         if (ret)
2168                                 goto fail;
2169                 }
2170                 offset = end_byte;
2171         }
2172         for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
2173                 offset = btrfs_sb_offset(i);
2174                 offset &= ~((u64)STRIPE_LEN - 1);
2175
2176                 ret = relocate_extents_range(fs_root, ext2_root,
2177                                              offset, offset + STRIPE_LEN);
2178                 if (ret)
2179                         goto fail;
2180         }
2181         ret = 0;
2182 fail:
2183         return ret;
2184 }
2185
2186 static int fixup_chunk_mapping(struct btrfs_root *root)
2187 {
2188         struct btrfs_trans_handle *trans;
2189         struct btrfs_fs_info *info = root->fs_info;
2190         struct btrfs_root *chunk_root = info->chunk_root;
2191         struct extent_buffer *leaf;
2192         struct btrfs_key key;
2193         struct btrfs_path path;
2194         struct btrfs_chunk chunk;
2195         unsigned long ptr;
2196         u32 size;
2197         u64 type;
2198         int ret;
2199
2200         btrfs_init_path(&path);
2201
2202         trans = btrfs_start_transaction(root, 1);
2203         BUG_ON(!trans);
2204
2205         /*
2206          * recow the whole chunk tree. this will move all chunk tree blocks
2207          * into system block group.
2208          */
2209         memset(&key, 0, sizeof(key));
2210         while (1) {
2211                 ret = btrfs_search_slot(trans, chunk_root, &key, &path, 0, 1);
2212                 if (ret < 0)
2213                         goto err;
2214
2215                 ret = btrfs_next_leaf(chunk_root, &path);
2216                 if (ret < 0)
2217                         goto err;
2218                 if (ret > 0)
2219                         break;
2220
2221                 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
2222                 btrfs_release_path(chunk_root, &path);
2223         }
2224         btrfs_release_path(chunk_root, &path);
2225
2226         /* fixup the system chunk array in super block */
2227         btrfs_set_super_sys_array_size(&info->super_copy, 0);
2228
2229         key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
2230         key.offset = 0;
2231         key.type = BTRFS_CHUNK_ITEM_KEY;
2232
2233         ret = btrfs_search_slot(trans, chunk_root, &key, &path, 0, 0);
2234         if (ret < 0)
2235                 goto err;
2236         BUG_ON(ret != 0);
2237         while(1) {
2238                 leaf = path.nodes[0];
2239                 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
2240                         ret = btrfs_next_leaf(chunk_root, &path);
2241                         if (ret < 0)
2242                                 goto err;
2243                         if (ret > 0)
2244                                 break;
2245                         leaf = path.nodes[0];
2246                 }
2247                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
2248                 if (key.type != BTRFS_CHUNK_ITEM_KEY)
2249                         goto next;
2250
2251                 ptr = btrfs_item_ptr_offset(leaf, path.slots[0]);
2252                 size = btrfs_item_size_nr(leaf, path.slots[0]);
2253                 BUG_ON(size != sizeof(chunk));
2254                 read_extent_buffer(leaf, &chunk, ptr, size);
2255                 type = btrfs_stack_chunk_type(&chunk);
2256
2257                 if (!(type & BTRFS_BLOCK_GROUP_SYSTEM))
2258                         goto next;
2259
2260                 ret = btrfs_add_system_chunk(trans, chunk_root, &key,
2261                                              &chunk, size);
2262                 if (ret)
2263                         goto err;
2264 next:
2265                 path.slots[0]++;
2266         }
2267
2268         ret = btrfs_commit_transaction(trans, root);
2269         BUG_ON(ret);
2270 err:
2271         btrfs_release_path(chunk_root, &path);
2272         return ret;
2273 }
2274
2275 int do_convert(const char *devname, int datacsum, int packing, int noxattr)
2276 {
2277         int i, fd, ret;
2278         u32 blocksize;
2279         u64 blocks[7];
2280         u64 total_bytes;
2281         u64 super_bytenr;
2282         ext2_filsys ext2_fs;
2283         struct btrfs_root *root;
2284         struct btrfs_root *ext2_root;
2285
2286         ret = open_ext2fs(devname, &ext2_fs);
2287         if (ret) {
2288                 fprintf(stderr, "unable to open the Ext2fs\n");
2289                 goto fail;
2290         }
2291         blocksize = ext2_fs->blocksize;
2292         total_bytes = (u64)ext2_fs->super->s_blocks_count * blocksize;
2293         if (blocksize < 4096) {
2294                 fprintf(stderr, "block size is too small\n");
2295                 goto fail;
2296         }
2297         if (!(ext2_fs->super->s_feature_incompat &
2298               EXT2_FEATURE_INCOMPAT_FILETYPE)) {
2299                 fprintf(stderr, "filetype feature is missing\n");
2300                 goto fail;
2301         }
2302         for (i = 0; i < 7; i++) {
2303                 ret = ext2_alloc_block(ext2_fs, 0, blocks + i);
2304                 if (ret) {
2305                         fprintf(stderr, "not enough free space\n");
2306                         goto fail;
2307                 }
2308                 blocks[i] *= blocksize;
2309         }
2310         super_bytenr = blocks[0];
2311         fd = open(devname, O_RDWR);
2312         if (fd < 0) {
2313                 fprintf(stderr, "unable to open %s\n", devname);
2314                 goto fail;
2315         }
2316         ret = make_btrfs(fd, devname, ext2_fs->super->s_volume_name,
2317                          blocks, total_bytes, blocksize, blocksize,
2318                          blocksize, blocksize);
2319         if (ret) {
2320                 fprintf(stderr, "unable to create initial ctree\n");
2321                 goto fail;
2322         }
2323         /* create a system chunk that maps the whole device */
2324         ret = prepare_system_chunk(fd, super_bytenr, blocksize);
2325         if (ret) {
2326                 fprintf(stderr, "unable to update system chunk\n");
2327                 goto fail;
2328         }
2329         root = open_ctree_fd(fd, devname, super_bytenr, O_RDWR);
2330         if (!root) {
2331                 fprintf(stderr, "unable to open ctree\n");
2332                 goto fail;
2333         }
2334         ret = cache_free_extents(root, ext2_fs);
2335         if (ret) {
2336                 fprintf(stderr, "error during cache_free_extents %d\n", ret);
2337                 goto fail;
2338         }
2339         root->fs_info->extent_ops = &extent_ops;
2340         /* recover block allocation bitmap */
2341         for (i = 0; i < 7; i++) {
2342                 blocks[i] /= blocksize;
2343                 ext2_free_block(ext2_fs, blocks[i]);
2344         }
2345         ret = init_btrfs(root);
2346         if (ret) {
2347                 fprintf(stderr, "unable to setup the root tree\n");
2348                 goto fail;
2349         }
2350         printf("creating btrfs metadata.\n");
2351         ret = copy_inodes(root, ext2_fs, datacsum, packing, noxattr);
2352         if (ret) {
2353                 fprintf(stderr, "error during copy_inodes %d\n", ret);
2354                 goto fail;
2355         }
2356         printf("creating ext2fs image file.\n");
2357         ext2_root = link_subvol(root, "ext2_saved", EXT2_IMAGE_SUBVOL_OBJECTID);
2358         if (!ext2_root) {
2359                 fprintf(stderr, "unable to create subvol\n");
2360                 goto fail;
2361         }
2362         ret = create_ext2_image(ext2_root, ext2_fs, "image");
2363         if (ret) {
2364                 fprintf(stderr, "error during create_ext2_image %d\n", ret);
2365                 goto fail;
2366         }
2367         printf("cleaning up system chunk.\n");
2368         ret = cleanup_sys_chunk(root, ext2_root);
2369         if (ret) {
2370                 fprintf(stderr, "error during cleanup_sys_chunk %d\n", ret);
2371                 goto fail;
2372         }
2373         ret = close_ctree(root);
2374         if (ret) {
2375                 fprintf(stderr, "error during close_ctree %d\n", ret);
2376                 goto fail;
2377         }
2378         close_ext2fs(ext2_fs);
2379
2380         /*
2381          * If this step succeed, we get a mountable btrfs. Otherwise
2382          * the ext2fs is left unchanged.
2383          */
2384         ret = migrate_super_block(fd, super_bytenr, blocksize);
2385         if (ret) {
2386                 fprintf(stderr, "unable to migrate super block\n");
2387                 goto fail;
2388         }
2389
2390         root = open_ctree_fd(fd, devname, 0, O_RDWR);
2391         if (!root) {
2392                 fprintf(stderr, "unable to open ctree\n");
2393                 goto fail;
2394         }
2395         /* move chunk tree into system chunk. */
2396         ret = fixup_chunk_mapping(root);
2397         if (ret) {
2398                 fprintf(stderr, "error during fixup_chunk_tree\n");
2399                 goto fail;
2400         }
2401         ret = close_ctree(root);
2402         close(fd);
2403
2404         printf("conversion complete.\n");
2405         return 0;
2406 fail:
2407         fprintf(stderr, "conversion aborted.\n");
2408         return -1;
2409 }
2410
2411 static int may_rollback(struct btrfs_root *root)
2412 {
2413         struct btrfs_fs_info *info = root->fs_info;
2414         struct btrfs_multi_bio *multi = NULL;
2415         u64 bytenr;
2416         u64 length;
2417         u64 physical;
2418         u64 total_bytes;
2419         int num_stripes;
2420         int ret;
2421
2422         if (btrfs_super_num_devices(&info->super_copy) != 1)
2423                 goto fail;
2424
2425         bytenr = BTRFS_SUPER_INFO_OFFSET;
2426         total_bytes = btrfs_super_total_bytes(&root->fs_info->super_copy);
2427
2428         while (1) {
2429                 ret = btrfs_map_block(&info->mapping_tree, WRITE, bytenr,
2430                                       &length, &multi, 0);
2431                 if (ret)
2432                         goto fail;
2433
2434                 num_stripes = multi->num_stripes;
2435                 physical = multi->stripes[0].physical;
2436                 kfree(multi);
2437
2438                 if (num_stripes != 1 || physical != bytenr)
2439                         goto fail;
2440
2441                 bytenr += length;
2442                 if (bytenr >= total_bytes)
2443                         break;
2444         }
2445         return 0;
2446 fail:
2447         return -1;
2448 }
2449
2450 int do_rollback(const char *devname, int force)
2451 {
2452         int fd;
2453         int ret;
2454         int i;
2455         struct btrfs_root *root;
2456         struct btrfs_root *ext2_root;
2457         struct btrfs_root *chunk_root;
2458         struct btrfs_dir_item *dir;
2459         struct btrfs_inode_item *inode;
2460         struct btrfs_file_extent_item *fi;
2461         struct btrfs_trans_handle *trans;
2462         struct extent_buffer *leaf;
2463         struct btrfs_block_group_cache *cache1;
2464         struct btrfs_block_group_cache *cache2;
2465         struct btrfs_key key;
2466         struct btrfs_path path;
2467         struct extent_io_tree io_tree;
2468         char *buf;
2469         char *name;
2470         u64 bytenr;
2471         u64 num_bytes;
2472         u64 root_dir;
2473         u64 objectid;
2474         u64 offset;
2475         u64 start;
2476         u64 end;
2477         u64 sb_bytenr;
2478         u64 first_free;
2479         u64 total_bytes;
2480         u32 sectorsize;
2481
2482         extent_io_tree_init(&io_tree);
2483
2484         fd = open(devname, O_RDWR);
2485         if (fd < 0) {
2486                 fprintf(stderr, "unable to open %s\n", devname);
2487                 goto fail;
2488         }
2489         root = open_ctree_fd(fd, devname, 0, O_RDWR);
2490         if (!root) {
2491                 fprintf(stderr, "unable to open ctree\n");
2492                 goto fail;
2493         }
2494         ret = may_rollback(root);
2495         if (ret < 0) {
2496                 fprintf(stderr, "unable to do rollback\n");
2497                 goto fail;
2498         }
2499
2500         sectorsize = root->sectorsize;
2501         buf = malloc(sectorsize);
2502         if (!buf) {
2503                 fprintf(stderr, "unable to allocate memory\n");
2504                 goto fail;
2505         }
2506
2507         btrfs_init_path(&path);
2508
2509         key.objectid = EXT2_IMAGE_SUBVOL_OBJECTID;
2510         key.type = BTRFS_ROOT_ITEM_KEY;
2511         key.offset = (u64)-1;
2512         ext2_root = btrfs_read_fs_root(root->fs_info, &key);
2513         if (!ext2_root || IS_ERR(ext2_root)) {
2514                 fprintf(stderr, "unable to open subvol %llu\n",
2515                         key.objectid);
2516                 goto fail;
2517         }
2518
2519         name = "image";
2520         root_dir = btrfs_root_dirid(&root->root_item);
2521         dir = btrfs_lookup_dir_item(NULL, ext2_root, &path,
2522                                    root_dir, name, strlen(name), 0);
2523         if (!dir || IS_ERR(dir)) {
2524                 fprintf(stderr, "unable to find file %s\n", name);
2525                 goto fail;
2526         }
2527         leaf = path.nodes[0];
2528         btrfs_dir_item_key_to_cpu(leaf, dir, &key);
2529         btrfs_release_path(ext2_root, &path);
2530
2531         objectid = key.objectid;
2532
2533         ret = btrfs_lookup_inode(NULL, ext2_root, &path, &key, 0);
2534         if (ret) {
2535                 fprintf(stderr, "unable to find inode item\n");
2536                 goto fail;
2537         }
2538         leaf = path.nodes[0];
2539         inode = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_inode_item);
2540         total_bytes = btrfs_inode_size(leaf, inode);
2541         btrfs_release_path(ext2_root, &path);
2542
2543         key.objectid = objectid;
2544         key.offset = 0;
2545         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
2546         ret = btrfs_search_slot(NULL, ext2_root, &key, &path, 0, 0);
2547         if (ret != 0) {
2548                 fprintf(stderr, "unable to find first file extent\n");
2549                 btrfs_release_path(ext2_root, &path);
2550                 goto fail;
2551         }
2552
2553         /* build mapping tree for the relocated blocks */
2554         for (offset = 0; offset < total_bytes; ) {
2555                 leaf = path.nodes[0];
2556                 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
2557                         ret = btrfs_next_leaf(root, &path);
2558                         if (ret != 0)
2559                                 break;
2560                         continue;
2561                 }
2562
2563                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
2564                 if (key.objectid != objectid || key.offset != offset ||
2565                     btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
2566                         break;
2567
2568                 fi = btrfs_item_ptr(leaf, path.slots[0],
2569                                     struct btrfs_file_extent_item);
2570                 if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
2571                         break;
2572                 if (btrfs_file_extent_compression(leaf, fi) ||
2573                     btrfs_file_extent_encryption(leaf, fi) ||
2574                     btrfs_file_extent_other_encoding(leaf, fi))
2575                         break;
2576
2577                 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
2578                 /* skip holes and direct mapped extents */
2579                 if (bytenr == 0 || bytenr == offset)
2580                         goto next_extent;
2581
2582                 bytenr += btrfs_file_extent_offset(leaf, fi);
2583                 num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
2584
2585                 cache1 = btrfs_lookup_block_group(root->fs_info, offset);
2586                 cache2 =  btrfs_lookup_block_group(root->fs_info,
2587                                                    offset + num_bytes - 1);
2588                 if (!cache1 || cache1 != cache2 ||
2589                     (!(cache1->flags & BTRFS_BLOCK_GROUP_SYSTEM) &&
2590                      !intersect_with_sb(offset, num_bytes)))
2591                         break;
2592
2593                 set_extent_bits(&io_tree, offset, offset + num_bytes - 1,
2594                                 EXTENT_LOCKED, GFP_NOFS);
2595                 set_state_private(&io_tree, offset, bytenr);
2596 next_extent:
2597                 offset += btrfs_file_extent_num_bytes(leaf, fi);
2598                 path.slots[0]++;
2599         }
2600         btrfs_release_path(ext2_root, &path);
2601
2602         if (offset < total_bytes) {
2603                 fprintf(stderr, "unable to build extent mapping\n");
2604                 goto fail;
2605         }
2606
2607         first_free = BTRFS_SUPER_INFO_OFFSET + 2 * sectorsize - 1;
2608         first_free &= ~((u64)sectorsize - 1);
2609         /* backup for extent #0 should exist */
2610         if(!test_range_bit(&io_tree, 0, first_free - 1, EXTENT_LOCKED, 1)) {
2611                 fprintf(stderr, "no backup for the first extent\n");
2612                 goto fail;
2613         }
2614         /* force no allocation from system block group */
2615         root->fs_info->system_allocs = -1;
2616         trans = btrfs_start_transaction(root, 1);
2617         BUG_ON(!trans);
2618         /*
2619          * recow the whole chunk tree, this will remove all chunk tree blocks
2620          * from system block group
2621          */
2622         chunk_root = root->fs_info->chunk_root;
2623         memset(&key, 0, sizeof(key));
2624         while (1) {
2625                 ret = btrfs_search_slot(trans, chunk_root, &key, &path, 0, 1);
2626                 if (ret < 0)
2627                         break;
2628
2629                 ret = btrfs_next_leaf(chunk_root, &path);
2630                 if (ret)
2631                         break;
2632
2633                 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
2634                 btrfs_release_path(chunk_root, &path);
2635         }
2636         btrfs_release_path(chunk_root, &path);
2637
2638         offset = 0;
2639         num_bytes = 0;
2640         while(1) {
2641                 cache1 = btrfs_lookup_block_group(root->fs_info, offset);
2642                 if (!cache1)
2643                         break;
2644
2645                 if (cache1->flags & BTRFS_BLOCK_GROUP_SYSTEM)
2646                         num_bytes += btrfs_block_group_used(&cache1->item);
2647
2648                 offset = cache1->key.objectid + cache1->key.offset;
2649         }
2650         /* only extent #0 left in system block group? */
2651         if (num_bytes > first_free) {
2652                 fprintf(stderr, "unable to empty system block group\n");
2653                 goto fail;
2654         }
2655         /* create a system chunk that maps the whole device */
2656         ret = prepare_system_chunk_sb(&root->fs_info->super_copy);
2657         if (ret) {
2658                 fprintf(stderr, "unable to update system chunk\n");
2659                 goto fail;
2660         }
2661
2662         ret = btrfs_commit_transaction(trans, root);
2663         BUG_ON(ret);
2664
2665         ret = close_ctree(root);
2666         if (ret) {
2667                 fprintf(stderr, "error during close_ctree %d\n", ret);
2668                 goto fail;
2669         }
2670
2671         /* zero btrfs super block mirrors */
2672         memset(buf, 0, sectorsize);
2673         for (i = 1 ; i < BTRFS_SUPER_MIRROR_MAX; i++) {
2674                 bytenr = btrfs_sb_offset(i);
2675                 if (bytenr >= total_bytes)
2676                         break;
2677                 ret = pwrite(fd, buf, sectorsize, bytenr);
2678         }
2679
2680         sb_bytenr = (u64)-1;
2681         /* copy all relocated blocks back */
2682         while(1) {
2683                 ret = find_first_extent_bit(&io_tree, 0, &start, &end,
2684                                             EXTENT_LOCKED);
2685                 if (ret)
2686                         break;
2687
2688                 ret = get_state_private(&io_tree, start, &bytenr);
2689                 BUG_ON(ret);
2690
2691                 clear_extent_bits(&io_tree, start, end, EXTENT_LOCKED,
2692                                   GFP_NOFS);
2693
2694                 while (start <= end) {
2695                         if (start == BTRFS_SUPER_INFO_OFFSET) {
2696                                 sb_bytenr = bytenr;
2697                                 goto next_sector;
2698                         }
2699                         ret = pread(fd, buf, sectorsize, bytenr);
2700                         if (ret < 0) {
2701                                 fprintf(stderr, "error during pread %d\n", ret);
2702                                 goto fail;
2703                         }
2704                         BUG_ON(ret != sectorsize);
2705                         ret = pwrite(fd, buf, sectorsize, start);
2706                         if (ret < 0) {
2707                                 fprintf(stderr, "error during pwrite %d\n", ret);
2708                                 goto fail;
2709                         }
2710                         BUG_ON(ret != sectorsize);
2711 next_sector:
2712                         start += sectorsize;
2713                         bytenr += sectorsize;
2714                 }
2715         }
2716
2717         ret = fsync(fd);
2718         if (ret) {
2719                 fprintf(stderr, "error during fsync %d\n", ret);
2720                 goto fail;
2721         }
2722         /*
2723          * finally, overwrite btrfs super block.
2724          */
2725         ret = pread(fd, buf, sectorsize, sb_bytenr);
2726         if (ret < 0) {
2727                 fprintf(stderr, "error during pread %d\n", ret);
2728                 goto fail;
2729         }
2730         BUG_ON(ret != sectorsize);
2731         ret = pwrite(fd, buf, sectorsize, BTRFS_SUPER_INFO_OFFSET);
2732         if (ret < 0) {
2733                 fprintf(stderr, "error during pwrite %d\n", ret);
2734                 goto fail;
2735         }
2736         BUG_ON(ret != sectorsize);
2737         ret = fsync(fd);
2738         if (ret) {
2739                 fprintf(stderr, "error during fsync %d\n", ret);
2740                 goto fail;
2741         }
2742
2743         close(fd);
2744         free(buf);
2745         extent_io_tree_cleanup(&io_tree);
2746         printf("rollback complete.\n");
2747         return 0;
2748 fail:
2749         fprintf(stderr, "rollback aborted.\n");
2750         return -1;
2751 }
2752
2753 static void print_usage(void)
2754 {
2755         printf("usage: btrfs-convert [-d] [-i] [-n] [-r] device\n");
2756         printf("\t-d disable data checksum\n");
2757         printf("\t-i ignore xattrs and ACLs\n");
2758         printf("\t-n disable packing of small files\n");
2759         printf("\t-r roll back to ext2fs\n");
2760 }
2761
2762 int main(int argc, char *argv[])
2763 {
2764         int ret;
2765         int packing = 1;
2766         int noxattr = 0;
2767         int datacsum = 1;
2768         int rollback = 0;
2769         char *file;
2770         while(1) {
2771                 int c = getopt(argc, argv, "dinr");
2772                 if (c < 0)
2773                         break;
2774                 switch(c) {
2775                         case 'd':
2776                                 datacsum = 0;
2777                                 break;
2778                         case 'i':
2779                                 noxattr = 1;
2780                                 break;
2781                         case 'n':
2782                                 packing = 0;
2783                                 break;
2784                         case 'r':
2785                                 rollback = 1;
2786                                 break;
2787                         default:
2788                                 print_usage();
2789                                 return 1;
2790                 }
2791         }
2792         argc = argc - optind;
2793         if (argc != 1) {
2794                 print_usage();
2795                 return 1;
2796         }
2797
2798         file = argv[optind];
2799         if (check_mounted(file)) {
2800                 fprintf(stderr, "%s is mounted\n", file);
2801                 return 1;
2802         }
2803
2804         if (rollback) {
2805                 ret = do_rollback(file, 0);
2806         } else {
2807                 ret = do_convert(file, datacsum, packing, noxattr);
2808         }
2809         if (ret)
2810                 return 1;
2811         return 0;
2812 }