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