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 500
  20 #ifndef __CHECKER__
  21 #include <sys/ioctl.h>
  22 #include <sys/mount.h>
  23 #endif
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <fcntl.h>
  29 #include <unistd.h>
  30 #include <uuid/uuid.h>
  31 #include <linux/fs.h>
  32 #include "kerncompat.h"
  33 #include "ctree.h"
  34 #include "disk-io.h"
  35 #include "transaction.h"
  36 #include "crc32c.h"
  37 #include "utils.h"
  38 #include "ext2fs/ext2_fs.h"
  39 #include "ext2fs/ext2fs.h"
  40
  41 #define INO_OFFSET (BTRFS_FIRST_FREE_OBJECTID - EXT2_ROOT_INO)
  42
  43 /*
  44  * Open Ext2fs in readonly mode, read block allocation bitmap and
  45  * inode bitmap into memory.
  46  */
  47 static int open_ext2fs(const char *name, ext2_filsys *ret_fs)
  48 {
  49         int mnt_flags;
  50         errcode_t ret;
  51         ext2_filsys ext2_fs;
  52
  53         ret = ext2fs_check_if_mounted(name, &mnt_flags);
  54         if (ret) {
  55                 fprintf(stderr, "ext2fs_check_if_mounted: %s\n",
  56                         error_message(ret));
  57                 return -1;
  58         }
  59         if (mnt_flags & EXT2_MF_MOUNTED) {
  60                 fprintf(stderr, "%s is mounted\n", name);
  61                 return -1;
  62         }
  63         ret = ext2fs_open(name, 0, 0, 0, unix_io_manager, &ext2_fs);
  64         if (ret) {
  65                 fprintf(stderr, "ext2fs_open: %s\n", error_message(ret));
  66                 goto fail;
  67         }
  68         ret = ext2fs_read_inode_bitmap(ext2_fs);
  69         if (ret) {
  70                 fprintf(stderr, "ext2fs_read_inode_bitmap: %s\n",
  71                         error_message(ret));
  72                 goto fail;
  73         }
  74         ret = ext2fs_read_block_bitmap(ext2_fs);
  75         if (ret) {
  76                 fprintf(stderr, "ext2fs_read_block_bitmap: %s\n",
  77                         error_message(ret));
  78                 goto fail;
  79         }
  80         *ret_fs = ext2_fs;
  81         return 0;
  82 fail:
  83         return -1;
  84 }
  85
  86 static int close_ext2fs(ext2_filsys fs)
  87 {
  88         ext2fs_close(fs);
  89         return 0;
  90 }
  91 static int ext2_alloc_block(ext2_filsys fs, u64 goal, u64 *block_ret)
  92 {
  93         blk_t block;
  94
  95         if (!ext2fs_new_block(fs, goal, NULL, &block)) {
  96                 ext2fs_fast_mark_block_bitmap(fs->block_map, block);
  97                 *block_ret = block;
  98                 return 0;
  99         }
 100         return -ENOSPC;
 101 }
 102
 103 static int ext2_free_block(ext2_filsys fs, u64 block)
 104 {
 105         BUG_ON(block != (blk_t)block);
 106         ext2fs_fast_unmark_block_bitmap(fs->block_map, block);
 107         return 0;
 108 }
 109
 110 static int custom_alloc_extent(struct btrfs_root *root, u64 num_bytes,
 111                                u64 hint_byte, struct btrfs_key *ins)
 112 {
 113         ext2_filsys fs = (ext2_filsys)root->fs_info->priv_data;
 114         u32 blocksize = fs->blocksize;
 115         u64 first = 0;
 116         u64 block;
 117         u64 bytenr;
 118         int ret;
 119
 120         block = hint_byte / blocksize;
 121         BUG_ON(block != (blk_t)block);
 122         BUG_ON(num_bytes != blocksize);
 123         while (1) {
 124                 ret = ext2_alloc_block(fs, block, &block);
 125                 if (ret)
 126                         return ret;
 127                 /* all free blocks are pinned */
 128                 if (first == block)
 129                         return -ENOSPC;
 130                 if (first == 0)
 131                         first = block;
 132
 133                 bytenr = block * blocksize;
 134                 if (!test_range_bit(&root->fs_info->pinned_extents, bytenr,
 135                                     bytenr + blocksize - 1, EXTENT_DIRTY, 0))
 136                         break;
 137
 138                 ext2_free_block(fs, block);
 139                 block++;
 140         }
 141         ins->objectid = bytenr;
 142         ins->offset = blocksize;
 143         btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
 144         return 0;
 145 }
 146
 147 static int custom_free_extent(struct btrfs_root *root, u64 bytenr,
 148                               u64 num_bytes)
 149 {
 150         u64 block;
 151         ext2_filsys fs = (ext2_filsys)root->fs_info->priv_data;
 152
 153         BUG_ON(bytenr & (fs->blocksize - 1));
 154         block = bytenr / fs->blocksize;
 155         while (num_bytes > 0) {
 156                 ext2_free_block(fs, block);
 157                 block++;
 158                 num_bytes -= fs->blocksize;
 159         }
 160         return 0;
 161 }
 162
 163 struct btrfs_extent_ops extent_ops = {
 164         .alloc_extent = custom_alloc_extent,
 165         .free_extent = custom_free_extent,
 166 };
 167
 168 struct dir_iterate_data {
 169         struct btrfs_trans_handle *trans;
 170         struct btrfs_root *root;
 171         struct btrfs_inode_item *inode;
 172         u64 objectid;
 173         u64 parent;
 174         int errcode;
 175 };
 176 static u8 filetype_conversion_table[EXT2_FT_MAX] = {
 177         [EXT2_FT_UNKNOWN]       = BTRFS_FT_UNKNOWN,
 178         [EXT2_FT_REG_FILE]      = BTRFS_FT_REG_FILE,
 179         [EXT2_FT_DIR]           = BTRFS_FT_DIR,
 180         [EXT2_FT_CHRDEV]        = BTRFS_FT_CHRDEV,
 181         [EXT2_FT_BLKDEV]        = BTRFS_FT_BLKDEV,
 182         [EXT2_FT_FIFO]          = BTRFS_FT_FIFO,
 183         [EXT2_FT_SOCK]          = BTRFS_FT_SOCK,
 184         [EXT2_FT_SYMLINK]       = BTRFS_FT_SYMLINK,
 185 };
 186
 187 static int dir_iterate_proc(ext2_ino_t dir, int entry,
 188                             struct ext2_dir_entry *old,
 189                             int offset, int blocksize,
 190                             char *buf,void *priv_data)
 191 {
 192         int ret;
 193         int file_type;
 194         u64 objectid;
 195         u64 inode_size;
 196         char dotdot[] = "..";
 197         struct btrfs_key location;
 198         struct ext2_dir_entry_2 *dirent = (struct ext2_dir_entry_2 *)old;
 199         struct dir_iterate_data *idata = (struct dir_iterate_data *)priv_data;
 200
 201         objectid = dirent->inode + INO_OFFSET;
 202         if (!strncmp(dirent->name, dotdot, dirent->name_len)) {
 203                 if (dirent->name_len == 2) {
 204                         BUG_ON(idata->parent != 0);
 205                         idata->parent = objectid;
 206                 }
 207                 return 0;
 208         }
 209         if (dirent->inode < EXT2_GOOD_OLD_FIRST_INO)
 210                 return 0;
 211
 212         location.objectid = objectid;
 213         location.offset = 0;
 214         btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
 215
 216         file_type = dirent->file_type;
 217         BUG_ON(file_type > EXT2_FT_SYMLINK);
 218         ret = btrfs_insert_dir_item(idata->trans, idata->root,
 219                                     dirent->name, dirent->name_len,
 220                                     idata->objectid, &location,
 221                                     filetype_conversion_table[file_type]);
 222         if (ret)
 223                 goto fail;
 224         ret = btrfs_insert_inode_ref(idata->trans, idata->root,
 225                                      dirent->name, dirent->name_len,
 226                                      objectid, idata->objectid);
 227         if (ret)
 228                 goto fail;
 229         inode_size = btrfs_stack_inode_size(idata->inode) +
 230                      dirent->name_len * 2;
 231         btrfs_set_stack_inode_size(idata->inode, inode_size);
 232         return 0;
 233 fail:
 234         idata->errcode = ret;
 235         return BLOCK_ABORT;
 236 }
 237
 238 static int create_dir_entries(struct btrfs_trans_handle *trans,
 239                               struct btrfs_root *root, u64 objectid,
 240                               struct btrfs_inode_item *btrfs_inode,
 241                               ext2_filsys ext2_fs, ext2_ino_t ext2_ino)
 242 {
 243         int ret;
 244         errcode_t err;
 245         struct dir_iterate_data data = {
 246                 .trans          = trans,
 247                 .root           = root,
 248                 .inode          = btrfs_inode,
 249                 .objectid       = objectid,
 250                 .parent         = 0,
 251                 .errcode        = 0,
 252         };
 253
 254         err = ext2fs_dir_iterate2(ext2_fs, ext2_ino, 0, NULL,
 255                                   dir_iterate_proc, &data);
 256         if (err)
 257                 goto error;
 258         ret = data.errcode;
 259         if (ret == 0 && data.parent == objectid) {
 260                 ret = btrfs_insert_inode_ref(trans, root, "..", 2,
 261                                              objectid, objectid);
 262         }
 263         return ret;
 264 error:
 265         fprintf(stderr, "ext2fs_dir_iterate2: %s\n", error_message(err));
 266         return -1;
 267 }
 268
 269 static int read_disk_extent(struct btrfs_root *root, u64 bytenr,
 270                             u32 num_bytes, char *buffer)
 271 {
 272         int ret;
 273         struct btrfs_fs_info *fs_info = root->fs_info;
 274
 275         ret = pread(fs_info->fp, buffer, num_bytes, bytenr);
 276         if (ret != num_bytes)
 277                 goto fail;
 278         ret = 0;
 279 fail:
 280         if (ret > 0)
 281                 ret = -1;
 282         return ret;
 283 }
 284 /*
 285  * Record a file extent. Do all the required works, such as inserting
 286  * file extent item, inserting extent item and backref item into extent
 287  * tree and updating block accounting.
 288  */
 289 static int record_file_extent(struct btrfs_trans_handle *trans,
 290                               struct btrfs_root *root, u64 objectid,
 291                               struct btrfs_inode_item *inode,
 292                               u64 file_pos, u64 disk_bytenr,
 293                               u64 num_bytes, int checksum)
 294 {
 295         int ret;
 296         struct btrfs_fs_info *info = root->fs_info;
 297         struct btrfs_root *extent_root = info->extent_root;
 298         struct btrfs_key ins_key;
 299         struct btrfs_path path;
 300         struct btrfs_extent_item extent_item;
 301         u32 blocksize = root->sectorsize;
 302         u64 nblocks;
 303         u64 bytes_used;
 304
 305         ret = btrfs_insert_file_extent(trans, root, objectid, file_pos,
 306                                        disk_bytenr, num_bytes, num_bytes);
 307         if (ret || disk_bytenr == 0)
 308                 return ret;
 309
 310         nblocks = btrfs_stack_inode_nblocks(inode) + num_bytes / 512;
 311         btrfs_set_stack_inode_nblocks(inode, nblocks);
 312         if (checksum) {
 313                 u64 offset;
 314                 char *buffer;
 315
 316                 ret = -ENOMEM;
 317                 buffer = malloc(blocksize);
 318                 if (!buffer)
 319                         goto fail;
 320                 for (offset = 0; offset < num_bytes; offset += blocksize) {
 321                         ret = read_disk_extent(root, disk_bytenr + offset,
 322                                                 blocksize, buffer);
 323                         if (ret)
 324                                 break;
 325                         ret = btrfs_csum_file_block(trans, root, inode,
 326                                                 objectid, file_pos + offset,
 327                                                 buffer, blocksize);
 328                         if (ret)
 329                                 break;
 330                 }
 331                 free(buffer);
 332                 if (ret)
 333                         goto fail;
 334         }
 335
 336         bytes_used = btrfs_root_used(&root->root_item);
 337         btrfs_set_root_used(&root->root_item, bytes_used + num_bytes);
 338         ins_key.objectid = disk_bytenr;
 339         ins_key.offset = num_bytes;
 340         btrfs_set_key_type(&ins_key, BTRFS_EXTENT_ITEM_KEY);
 341         btrfs_set_stack_extent_refs(&extent_item, 1);
 342         ret = btrfs_insert_item(trans, extent_root, &ins_key,
 343                                 &extent_item, sizeof(extent_item));
 344         if (ret == 0) {
 345                 bytes_used = btrfs_super_bytes_used(&info->super_copy);
 346                 btrfs_set_super_bytes_used(&info->super_copy, bytes_used +
 347                                            num_bytes);
 348                 btrfs_init_path(&path);
 349                 ret = btrfs_insert_extent_backref(trans, extent_root, &path,
 350                                         disk_bytenr, root->root_key.objectid,
 351                                         trans->transid, objectid, file_pos);
 352                 if (ret)
 353                         goto fail;
 354                 ret = btrfs_update_block_group(trans, root, disk_bytenr,
 355                                                num_bytes, 1, 0, 1);
 356         } else if (ret == -EEXIST) {
 357                 ret = btrfs_inc_extent_ref(trans, root, disk_bytenr, num_bytes,
 358                                            root->root_key.objectid,
 359                                            trans->transid, objectid, file_pos);
 360         }
 361         if (ret)
 362                 goto fail;
 363         btrfs_extent_post_op(trans, extent_root);
 364         return 0;
 365 fail:
 366         return ret;
 367 }
 368
 369 static int record_file_blocks(struct btrfs_trans_handle *trans,
 370                               struct btrfs_root *root, u64 objectid,
 371                               struct btrfs_inode_item *inode,
 372                               u64 file_block, u64 disk_block,
 373                               u64 num_blocks, int checksum)
 374 {
 375         u64 file_pos = file_block * root->sectorsize;
 376         u64 disk_bytenr = disk_block * root->sectorsize;
 377         u64 num_bytes = num_blocks * root->sectorsize;
 378         return record_file_extent(trans, root, objectid, inode, file_pos,
 379                                   disk_bytenr, num_bytes, checksum);
 380 }
 381
 382 struct blk_iterate_data {
 383         struct btrfs_trans_handle *trans;
 384         struct btrfs_root *root;
 385         struct btrfs_inode_item *inode;
 386         u64 objectid;
 387         u64 first_block;
 388         u64 disk_block;
 389         u64 num_blocks;
 390         int checksum;
 391         int errcode;
 392 };
 393
 394 static int block_iterate_proc(ext2_filsys ext2_fs,
 395                               u64 disk_block, u64 file_block,
 396                               struct blk_iterate_data *idata)
 397 {
 398         int ret;
 399         u32 blocksize = ext2_fs->blocksize;
 400         struct btrfs_root *root = idata->root;
 401         struct btrfs_trans_handle *trans = idata->trans;
 402
 403         if ((file_block > idata->first_block + idata->num_blocks) ||
 404             (disk_block != idata->disk_block + idata->num_blocks) ||
 405             (idata->num_blocks >= BTRFS_BLOCK_GROUP_SIZE / blocksize)) {
 406                 if (idata->num_blocks > 0) {
 407                         ret = record_file_blocks(trans, root, idata->objectid,
 408                                         idata->inode, idata->first_block,
 409                                         idata->disk_block, idata->num_blocks,
 410                                         idata->checksum);
 411                         if (ret)
 412                                 goto fail;
 413                         idata->first_block += idata->num_blocks;
 414                         idata->num_blocks = 0;
 415                 }
 416                 if (file_block > idata->first_block) {
 417                         ret = record_file_blocks(trans, root, idata->objectid,
 418                                         idata->inode, idata->first_block,
 419                                         0, file_block - idata->first_block,
 420                                         idata->checksum);
 421                         if (ret)
 422                                 goto fail;
 423                 }
 424                 idata->first_block = file_block;
 425                 idata->disk_block = disk_block;
 426         }
 427         idata->num_blocks++;
 428         return 0;
 429 fail:
 430         idata->errcode = ret;
 431         return BLOCK_ABORT;
 432 }
 433
 434 static int __block_iterate_proc(ext2_filsys fs, blk_t *blocknr,
 435                                 e2_blkcnt_t blockcnt, blk_t ref_block,
 436                                 int ref_offset, void *priv_data)
 437 {
 438         struct blk_iterate_data *idata;
 439         idata = (struct blk_iterate_data *)priv_data;
 440         return block_iterate_proc(fs, *blocknr, blockcnt, idata);
 441 }
 442
 443 /*
 444  * traverse file's data blocks, record these data blocks as file extents.
 445  */
 446 static int create_file_extents(struct btrfs_trans_handle *trans,
 447                                struct btrfs_root *root, u64 objectid,
 448                                struct btrfs_inode_item *btrfs_inode,
 449                                ext2_filsys ext2_fs, ext2_ino_t ext2_ino)
 450 {
 451         int ret;
 452         char *buffer = NULL;
 453         errcode_t err;
 454         u32 last_block;
 455         u32 sectorsize = root->sectorsize;
 456         u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
 457         u32 inode_flags = btrfs_stack_inode_flags(btrfs_inode);
 458         struct blk_iterate_data data = {
 459                 .trans          = trans,
 460                 .root           = root,
 461                 .inode          = btrfs_inode,
 462                 .objectid       = objectid,
 463                 .first_block    = 0,
 464                 .disk_block     = 0,
 465                 .num_blocks     = 0,
 466                 .checksum       = 1,
 467                 .errcode        = 0,
 468         };
 469
 470         if (inode_flags & BTRFS_INODE_NODATASUM)
 471                 data.checksum = 0;
 472         err = ext2fs_block_iterate2(ext2_fs, ext2_ino, BLOCK_FLAG_DATA_ONLY,
 473                                     NULL, __block_iterate_proc, &data);
 474         if (err)
 475                 goto error;
 476         ret = data.errcode;
 477         if (ret)
 478                 goto fail;
 479
 480         if (data.first_block == 0 && data.num_blocks > 0 &&
 481             inode_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
 482                 u64 num_bytes = data.num_blocks * sectorsize;
 483                 u64 disk_bytenr = data.disk_block * sectorsize;
 484
 485                 buffer = malloc(num_bytes);
 486                 if (!buffer)
 487                         return -ENOMEM;
 488                 ret = read_disk_extent(root, disk_bytenr, num_bytes, buffer);
 489                 if (ret)
 490                         goto fail;
 491                 if (num_bytes > inode_size)
 492                         num_bytes = inode_size;
 493                 ret = btrfs_insert_inline_extent(trans, root, objectid,
 494                                                  0, buffer, num_bytes);
 495                 if (ret)
 496                         goto fail;
 497         } else if (data.num_blocks > 0) {
 498                 ret = record_file_blocks(trans, root, objectid, btrfs_inode,
 499                                          data.first_block, data.disk_block,
 500                                          data.num_blocks, data.checksum);
 501                 if (ret)
 502                         goto fail;
 503         }
 504         data.first_block += data.num_blocks;
 505         last_block = (inode_size + sectorsize - 1) / sectorsize;
 506         if (last_block > data.first_block) {
 507                 ret = record_file_blocks(trans, root, objectid, btrfs_inode,
 508                                          data.first_block, 0, last_block -
 509                                          data.first_block, data.checksum);
 510         }
 511 fail:
 512         if (buffer)
 513                 free(buffer);
 514         return ret;
 515 error:
 516         fprintf(stderr, "ext2fs_block_iterate2: %s\n", error_message(err));
 517         return -1;
 518 }
 519
 520 static int create_symbol_link(struct btrfs_trans_handle *trans,
 521                               struct btrfs_root *root, u64 objectid,
 522                               struct btrfs_inode_item *btrfs_inode,
 523                               ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
 524                               struct ext2_inode *ext2_inode)
 525 {
 526         int ret;
 527         char *pathname;
 528         u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
 529         if (ext2fs_inode_data_blocks(ext2_fs, ext2_inode)) {
 530                 btrfs_set_stack_inode_size(btrfs_inode, inode_size + 1);
 531                 ret = create_file_extents(trans, root, objectid,
 532                                           btrfs_inode, ext2_fs, ext2_ino);
 533                 btrfs_set_stack_inode_size(btrfs_inode, inode_size);
 534                 return ret;
 535         }
 536
 537         pathname = (char *)&(ext2_inode->i_block[0]);
 538         BUG_ON(pathname[inode_size] != 0);
 539         ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
 540                                          pathname, inode_size + 1);
 541         return ret;
 542 }
 543
 544 #define MINORBITS       20
 545 #define MKDEV(ma, mi)   (((ma) << MINORBITS) | (mi))
 546
 547 static inline dev_t old_decode_dev(u16 val)
 548 {
 549         return MKDEV((val >> 8) & 255, val & 255);
 550 }
 551
 552 static inline dev_t new_decode_dev(u32 dev)
 553 {
 554         unsigned major = (dev & 0xfff00) >> 8;
 555         unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);
 556         return MKDEV(major, minor);
 557 }
 558
 559 static int copy_inode_item(struct btrfs_inode_item *dst,
 560                            struct ext2_inode *src)
 561 {
 562         btrfs_set_stack_inode_generation(dst, 1);
 563         btrfs_set_stack_inode_size(dst, src->i_size);
 564         btrfs_set_stack_inode_nblocks(dst, src->i_blocks);
 565         btrfs_set_stack_inode_block_group(dst, 0);
 566         btrfs_set_stack_inode_nblocks(dst, 0);
 567         btrfs_set_stack_inode_nlink(dst, src->i_links_count);
 568         btrfs_set_stack_inode_uid(dst, src->i_uid | (src->i_uid_high << 16));
 569         btrfs_set_stack_inode_gid(dst, src->i_gid | (src->i_gid_high << 16));
 570         btrfs_set_stack_inode_mode(dst, src->i_mode);
 571         btrfs_set_stack_inode_rdev(dst, 0);
 572         btrfs_set_stack_inode_flags(dst, 0);
 573         btrfs_set_stack_inode_compat_flags(dst, 0);
 574         btrfs_set_stack_timespec_sec(&dst->atime, src->i_atime);
 575         btrfs_set_stack_timespec_nsec(&dst->atime, 0);
 576         btrfs_set_stack_timespec_sec(&dst->ctime, src->i_ctime);
 577         btrfs_set_stack_timespec_nsec(&dst->ctime, 0);
 578         btrfs_set_stack_timespec_sec(&dst->mtime, src->i_mtime);
 579         btrfs_set_stack_timespec_nsec(&dst->mtime, 0);
 580         btrfs_set_stack_timespec_sec(&dst->otime, 0);
 581         btrfs_set_stack_timespec_nsec(&dst->otime, 0);
 582
 583         if (S_ISDIR(src->i_mode)) {
 584                 btrfs_set_stack_inode_size(dst, 0);
 585                 btrfs_set_stack_inode_nlink(dst, 1);
 586         }
 587         if (!S_ISREG(src->i_mode) && !S_ISDIR(src->i_mode) &&
 588             !S_ISLNK(src->i_mode)) {
 589                 if (src->i_block[0]) {
 590                         btrfs_set_stack_inode_rdev(dst,
 591                                 old_decode_dev(src->i_block[0]));
 592                 } else {
 593                         btrfs_set_stack_inode_rdev(dst,
 594                                 new_decode_dev(src->i_block[1]));
 595                 }
 596         }
 597         return 0;
 598 }
 599
 600 /*
 601  * copy a single inode. do all the required works, such as cloning
 602  * inode item, creating file extents and creating directory entries.
 603  */
 604 static int copy_single_inode(struct btrfs_trans_handle *trans,
 605                              struct btrfs_root *root, u64 objectid,
 606                              ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
 607                              int datacsum)
 608 {
 609         int ret;
 610         errcode_t err;
 611         struct ext2_inode ext2_inode;
 612         struct btrfs_key inode_key;
 613         struct btrfs_inode_item btrfs_inode;
 614
 615         err = ext2fs_read_inode(ext2_fs, ext2_ino, &ext2_inode);
 616         if (err)
 617                 goto error;
 618
 619         if (!ext2_inode.i_links_count &&
 620             (!ext2_inode.i_mode || ext2_inode.i_dtime)) {
 621                 printf("skip inode %u\n", ext2_ino);
 622                 return 0;
 623         }
 624         copy_inode_item(&btrfs_inode, &ext2_inode);
 625         if (!datacsum && S_ISREG(ext2_inode.i_mode)) {
 626                 u32 flags = btrfs_stack_inode_flags(&btrfs_inode) |
 627                             BTRFS_INODE_NODATASUM;
 628                 btrfs_set_stack_inode_flags(&btrfs_inode, flags);
 629         }
 630
 631         switch (ext2_inode.i_mode & S_IFMT) {
 632         case S_IFREG:
 633                 ret = create_file_extents(trans, root, objectid, &btrfs_inode,
 634                                           ext2_fs, ext2_ino);
 635                 break;
 636         case S_IFDIR:
 637                 ret = create_dir_entries(trans, root, objectid, &btrfs_inode,
 638                                          ext2_fs, ext2_ino);
 639                 break;
 640         case S_IFLNK:
 641                 ret = create_symbol_link(trans, root, objectid, &btrfs_inode,
 642                                          ext2_fs, ext2_ino, &ext2_inode);
 643                 break;
 644         default:
 645                 ret = 0;
 646                 break;
 647         }
 648         if (ret)
 649                 return ret;
 650         inode_key.objectid = objectid;
 651         inode_key.offset = 0;
 652         btrfs_set_key_type(&inode_key, BTRFS_INODE_ITEM_KEY);
 653         ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
 654         return ret;
 655 error:
 656         fprintf(stderr, "ext2fs_read_inode: %s\n", error_message(err));
 657         return -1;
 658 }
 659
 660 static int copy_disk_extent(struct btrfs_root *root, u64 dst_bytenr,
 661                             u64 src_bytenr, u32 num_bytes)
 662 {
 663         int ret;
 664         char *buffer;
 665         struct btrfs_fs_info *fs_info = root->fs_info;
 666
 667         buffer = malloc(num_bytes);
 668         if (!buffer)
 669                 return -ENOMEM;
 670         ret = pread(fs_info->fp, buffer, num_bytes, src_bytenr);
 671         if (ret != num_bytes)
 672                 goto fail;
 673         ret = pwrite(fs_info->fp, buffer, num_bytes, dst_bytenr);
 674         if (ret != num_bytes)
 675                 goto fail;
 676         ret = 0;
 677 fail:
 678         free(buffer);
 679         if (ret > 0)
 680                 ret = -1;
 681         return ret;
 682 }
 683
 684 /*
 685  * scan ext2's inode bitmap and copy all used inode.
 686  */
 687 static int copy_inodes(struct btrfs_root *root, ext2_filsys ext2_fs,
 688                        int datacsum)
 689 {
 690         int ret;
 691         ext2_ino_t ext2_ino;
 692         u64 objectid;
 693         struct btrfs_trans_handle *trans;
 694
 695         trans = btrfs_start_transaction(root, 1);
 696         if (!trans)
 697                 return -ENOMEM;
 698         ext2_ino = ext2_fs->inode_map->start;
 699         for (; ext2_ino <= ext2_fs->inode_map->end; ext2_ino++) {
 700                 if (ext2fs_fast_test_inode_bitmap(ext2_fs->inode_map,
 701                                                   ext2_ino)) {
 702                         /* skip special inode in ext2fs */
 703                         if (ext2_ino < EXT2_GOOD_OLD_FIRST_INO &&
 704                             ext2_ino != EXT2_ROOT_INO)
 705                                 continue;
 706                         objectid = ext2_ino + INO_OFFSET;
 707                         ret = copy_single_inode(trans, root, objectid,
 708                                         ext2_fs, ext2_ino, datacsum);
 709                         if (ret)
 710                                 return ret;
 711                 }
 712                 if (trans->blocks_used >= 8192) {
 713                         ret = btrfs_commit_transaction(trans, root);
 714                         BUG_ON(ret);
 715                         trans = btrfs_start_transaction(root, 1);
 716                         BUG_ON(!trans);
 717                 }
 718         }
 719         ret = btrfs_commit_transaction(trans, root);
 720         BUG_ON(ret);
 721
 722         return ret;
 723 }
 724 static int lookup_extent_item(struct btrfs_trans_handle *trans,
 725                              struct btrfs_root *root,
 726                              u64 bytenr, u64 num_bytes)
 727 {
 728         int ret;
 729         struct btrfs_key key;
 730         struct btrfs_path path;
 731         btrfs_init_path(&path);
 732         key.objectid = bytenr;
 733         key.offset = num_bytes;
 734         btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
 735         ret = btrfs_search_slot(trans, root->fs_info->extent_root,
 736                                 &key, &path, 0, 0);
 737         btrfs_release_path(root, &path);
 738         return ret;
 739 }
 740
 741 /*
 742  * Construct a range of ext2fs image file.
 743  * scan block allocation bitmap, find all blocks used by the ext2fs
 744  * in this range and create file extents that point to these blocks.
 745  *
 746  * Note: Before calling the function, no file extent points to blocks
 747  *       in this range
 748  */
 749 static int create_image_file_range(struct btrfs_trans_handle *trans,
 750                                    struct btrfs_root *root, u64 objectid,
 751                                    struct btrfs_inode_item *inode,
 752                                    u64 start_byte, u64 end_byte,
 753                                    ext2_filsys ext2_fs)
 754 {
 755         u64 bytenr;
 756         u32 blocksize = ext2_fs->blocksize;
 757         u32 block = start_byte / blocksize;
 758         u32 last_block = (end_byte + blocksize - 1) / blocksize;
 759         int ret;
 760         struct blk_iterate_data data = {
 761                 .trans          = trans,
 762                 .root           = root,
 763                 .inode          = inode,
 764                 .objectid       = objectid,
 765                 .first_block    = block,
 766                 .disk_block     = block,
 767                 .num_blocks     = 0,
 768                 .checksum       = 0,
 769                 .errcode        = 0,
 770         };
 771         for (; start_byte < end_byte; block++, start_byte += blocksize) {
 772                 if (!ext2fs_fast_test_block_bitmap(ext2_fs->block_map, block))
 773                         continue;
 774                 /* the bit may be set by us, check extent tree */
 775                 bytenr = (u64)block * blocksize;
 776                 ret = lookup_extent_item(trans, root, bytenr, blocksize);
 777                 if (ret < 0)
 778                         goto fail;
 779                 if (ret == 0)
 780                         continue;
 781
 782                 ret = block_iterate_proc(ext2_fs, block, block, &data);
 783                 if (ret & BLOCK_ABORT)
 784                         break;
 785         }
 786         ret = data.errcode;
 787         if (ret)
 788                 return ret;
 789         if (data.num_blocks > 0) {
 790                 ret = record_file_blocks(trans, root, objectid, inode,
 791                                          data.first_block, data.disk_block,
 792                                          data.num_blocks, 0);
 793                 if (ret)
 794                         return ret;
 795                 data.first_block += data.num_blocks;
 796         }
 797         if (last_block > data.first_block) {
 798                 ret = record_file_blocks(trans, root, objectid, inode,
 799                                          data.first_block, 0, last_block -
 800                                          data.first_block, 0);
 801                 if (ret)
 802                         return ret;
 803         }
 804 fail:
 805         return 0;
 806 }
 807
 808 /*
 809  * Create the ext2fs image file.
 810  */
 811 static int create_ext2_image(struct btrfs_root *root, ext2_filsys ext2_fs,
 812                              const char *name)
 813 {
 814         int ret;
 815         struct btrfs_key key;
 816         struct btrfs_key location;
 817         struct btrfs_path path;
 818         struct btrfs_inode_item btrfs_inode;
 819         struct extent_buffer *leaf;
 820         struct btrfs_fs_info *fs_info = root->fs_info;
 821         struct btrfs_root *extent_root = fs_info->extent_root;
 822         struct btrfs_trans_handle *trans;
 823         struct btrfs_extent_ref *ref_item;
 824         u64 bytenr;
 825         u64 num_bytes;
 826         u64 ref_root;
 827         u64 ref_owner;
 828         u64 objectid;
 829         u64 new_block;
 830         u64 last_byte;
 831         u64 first_free;
 832         u64 total_bytes;
 833         u32 sectorsize = root->sectorsize;
 834         int slot;
 835         int file_extent;
 836
 837         total_bytes = btrfs_super_total_bytes(&fs_info->super_copy);
 838         first_free =  BTRFS_SUPER_INFO_OFFSET + sectorsize * 2 - 1;
 839         first_free &= ~((u64)sectorsize - 1);
 840
 841         memset(&btrfs_inode, 0, sizeof(btrfs_inode));
 842         btrfs_set_stack_inode_generation(&btrfs_inode, 1);
 843         btrfs_set_stack_inode_size(&btrfs_inode, total_bytes);
 844         btrfs_set_stack_inode_nlink(&btrfs_inode, 1);
 845         btrfs_set_stack_inode_nblocks(&btrfs_inode, 0);
 846         btrfs_set_stack_inode_mode(&btrfs_inode, S_IFREG | 0400);
 847         btrfs_set_stack_inode_flags(&btrfs_inode, BTRFS_INODE_NODATASUM);
 848         btrfs_init_path(&path);
 849         trans = btrfs_start_transaction(root, 1);
 850         BUG_ON(!trans);
 851
 852         objectid = btrfs_root_dirid(&root->root_item);
 853         ret = btrfs_find_free_objectid(trans, root, objectid, &objectid);
 854         if (ret)
 855                 goto fail;
 856
 857         /*
 858          * copy the first a few blocks to new positions. the relocation is
 859          * reuqired for block 0 and default btrfs super block.
 860          */
 861         for (last_byte = 0; last_byte < first_free; last_byte += sectorsize) {
 862                 ret = ext2_alloc_block(ext2_fs, 0, &new_block);
 863                 if (ret)
 864                         goto fail;
 865                 new_block *= sectorsize;
 866                 ret = copy_disk_extent(root, new_block, last_byte, sectorsize);
 867                 if (ret)
 868                         goto fail;
 869                 ret = record_file_extent(trans, root, objectid,
 870                                          &btrfs_inode, last_byte,
 871                                          new_block, sectorsize, 0);
 872                 if (ret)
 873                         goto fail;
 874         }
 875 again:
 876         if (trans->blocks_used >= 8192) {
 877                 ret = btrfs_commit_transaction(trans, root);
 878                 BUG_ON(ret);
 879                 trans = btrfs_start_transaction(root, 1);
 880                 BUG_ON(!trans);
 881         }
 882
 883         key.objectid = last_byte;
 884         key.offset = 0;
 885         btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
 886         btrfs_release_path(extent_root, &path);
 887         ret = btrfs_search_slot(trans, fs_info->extent_root,
 888                                 &key, &path, 0, 0);
 889         if (ret < 0)
 890                 goto fail;
 891
 892         leaf = path.nodes[0];
 893         slot = path.slots[0];
 894         while(1) {
 895                 if (slot >= btrfs_header_nritems(leaf)) {
 896                         ret = btrfs_next_leaf(extent_root, &path);
 897                         if (ret < 0)
 898                                 goto fail;
 899                         if (ret > 0)
 900                                 break;
 901                         leaf = path.nodes[0];
 902                         slot = path.slots[0];
 903                 }
 904                 btrfs_item_key_to_cpu(leaf, &key, slot);
 905                 if (last_byte > key.objectid ||
 906                     key.type != BTRFS_EXTENT_ITEM_KEY) {
 907                         slot++;
 908                         continue;
 909                 }
 910                 /*
 911                  * Check backref to distinguish extent items for normal
 912                  * files (files that correspond to files in Ext2fs) from
 913                  * extent items for ctree blocks.
 914                  */
 915                 bytenr = key.objectid;
 916                 num_bytes = key.offset;
 917                 file_extent = 0;
 918                 while (1) {
 919                         if (slot >= btrfs_header_nritems(leaf)) {
 920                                 ret = btrfs_next_leaf(extent_root, &path);
 921                                 if (ret > 0)
 922                                         break;
 923                                 if (ret < 0)
 924                                         goto fail;
 925                                 leaf = path.nodes[0];
 926                                 slot = path.slots[0];
 927                         }
 928                         btrfs_item_key_to_cpu(leaf, &key, slot);
 929                         if (key.objectid != bytenr)
 930                                 break;
 931                         if (key.type != BTRFS_EXTENT_REF_KEY) {
 932                                 slot++;
 933                                 continue;
 934                         }
 935                         ref_item = btrfs_item_ptr(leaf, slot,
 936                                                   struct btrfs_extent_ref);
 937                         ref_root = btrfs_ref_root(leaf, ref_item);
 938                         ref_owner = btrfs_ref_objectid(leaf, ref_item);
 939                         if ((ref_root == BTRFS_FS_TREE_OBJECTID) &&
 940                             (ref_owner >= BTRFS_FIRST_FREE_OBJECTID)) {
 941                                 file_extent = 1;
 942                                 break;
 943                         }
 944                         slot++;
 945                 }
 946                 if (!file_extent)
 947                         continue;
 948
 949                 if (bytenr > last_byte) {
 950                         ret = create_image_file_range(trans, root, objectid,
 951                                                       &btrfs_inode, last_byte,
 952                                                       bytenr, ext2_fs);
 953                         if (ret)
 954                                 goto fail;
 955                 }
 956                 ret = record_file_extent(trans, root, objectid, &btrfs_inode,
 957                                          bytenr, bytenr, num_bytes, 0);
 958                 if (ret)
 959                         goto fail;
 960                 last_byte = bytenr + num_bytes;
 961                 goto again;
 962         }
 963         if (total_bytes > last_byte) {
 964                 ret = create_image_file_range(trans, root, objectid,
 965                                               &btrfs_inode, last_byte,
 966                                               total_bytes, ext2_fs);
 967                 if (ret)
 968                         goto fail;
 969         }
 970         /*
 971          * otime isn't used currently, so we can store some data in it.
 972          * These data are used by do_rollback to check whether the image
 973          * file have been modified.
 974          */
 975         btrfs_set_stack_timespec_sec(&btrfs_inode.otime, trans->transid);
 976         btrfs_set_stack_timespec_nsec(&btrfs_inode.otime,
 977                                       total_bytes / sectorsize);
 978         ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
 979         if (ret)
 980                 goto fail;
 981
 982         location.objectid = objectid;
 983         location.offset = 0;
 984         btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
 985         ret = btrfs_insert_dir_item(trans, root, name, strlen(name),
 986                                     btrfs_root_dirid(&root->root_item),
 987                                     &location, EXT2_FT_REG_FILE);
 988         if (ret)
 989                 goto fail;
 990         ret = btrfs_insert_inode_ref(trans, root, name, strlen(name),
 991                                      objectid,
 992                                      btrfs_root_dirid(&root->root_item));
 993         if (ret)
 994                 goto fail;
 995         ret = btrfs_commit_transaction(trans, root);
 996         BUG_ON(ret);
 997 fail:
 998         btrfs_release_path(root, &path);
 999         return ret;
1000 }
1001 struct btrfs_root *create_subvol(struct btrfs_root *root, const char *name)
1002 {
1003         int ret;
1004         u64 objectid;
1005         struct btrfs_key location;
1006         struct btrfs_root_item root_item;
1007         struct btrfs_trans_handle *trans;
1008         struct btrfs_fs_info *fs_info = root->fs_info;
1009         struct btrfs_root *tree_root = fs_info->tree_root;
1010         struct btrfs_root *new_root;
1011         struct extent_buffer *tmp;
1012
1013         trans = btrfs_start_transaction(root, 1);
1014         BUG_ON(!trans);
1015
1016         objectid = btrfs_super_root_dir(&fs_info->super_copy);
1017         ret = btrfs_find_free_objectid(trans, root, objectid, &objectid);
1018         if (ret)
1019                 goto fail;
1020         ret = btrfs_copy_root(trans, root, root->node, &tmp, objectid);
1021         if (ret)
1022                 goto fail;
1023         memcpy(&root_item, &root->root_item, sizeof(root_item));
1024         btrfs_set_root_bytenr(&root_item, tmp->start);
1025         btrfs_set_root_level(&root_item, btrfs_header_level(tmp));
1026         free_extent_buffer(tmp);
1027
1028         location.objectid = objectid;
1029         location.offset = 1;
1030         btrfs_set_key_type(&location, BTRFS_ROOT_ITEM_KEY);
1031         ret = btrfs_insert_root(trans, root->fs_info->tree_root,
1032                                 &location, &root_item);
1033         if (ret)
1034                 goto fail;
1035         location.offset = (u64)-1;
1036         ret = btrfs_insert_dir_item(trans, tree_root, name, strlen(name),
1037                                     btrfs_super_root_dir(&fs_info->super_copy),
1038                                     &location, BTRFS_FT_DIR);
1039         if (ret)
1040                 goto fail;
1041         ret = btrfs_insert_inode_ref(trans, tree_root, name, strlen(name),
1042                                      objectid,
1043                                      btrfs_super_root_dir(&fs_info->super_copy));
1044         if (ret)
1045                 goto fail;
1046         ret = btrfs_commit_transaction(trans, root);
1047         BUG_ON(ret);
1048         new_root = btrfs_read_fs_root(fs_info, &location);
1049         if (!new_root || IS_ERR(new_root))
1050                 goto fail;
1051         trans = btrfs_start_transaction(new_root, 1);
1052         BUG_ON(!trans);
1053         ret = btrfs_make_root_dir(trans, new_root, BTRFS_FIRST_FREE_OBJECTID);
1054         if (ret)
1055                 goto fail;
1056         ret = btrfs_commit_transaction(trans, new_root);
1057         BUG_ON(ret);
1058         return new_root;
1059 fail:
1060         return NULL;
1061 }
1062
1063 /*
1064  * Fixup block accounting. The initial block accounting created by
1065  * make_block_groups isn't accuracy in this case.
1066  */
1067 static int fixup_block_accounting(struct btrfs_trans_handle *trans,
1068                                   struct btrfs_root *root)
1069 {
1070         int ret;
1071         int slot;
1072         u64 start = 0;
1073         u64 bytes_used = 0;
1074         struct btrfs_path path;
1075         struct btrfs_key key;
1076         struct extent_buffer *leaf;
1077         struct btrfs_block_group_cache *cache;
1078         struct btrfs_fs_info *fs_info = root->fs_info;
1079
1080         while(1) {
1081                 cache = btrfs_lookup_block_group(fs_info, start);
1082                 if (!cache)
1083                         break;
1084                 start = cache->key.objectid + cache->key.offset;
1085                 btrfs_set_block_group_used(&cache->item, 0);
1086         }
1087
1088         btrfs_init_path(&path);
1089         key.offset = 0;
1090         key.objectid = 0;
1091         btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
1092         ret = btrfs_search_slot(trans, root->fs_info->extent_root,
1093                                 &key, &path, 0, 0);
1094         if (ret < 0)
1095                 return ret;
1096         while(1) {
1097                 leaf = path.nodes[0];
1098                 slot = path.slots[0];
1099                 if (slot >= btrfs_header_nritems(leaf)) {
1100                         ret = btrfs_next_leaf(root, &path);
1101                         if (ret < 0)
1102                                 return ret;
1103                         if (ret > 0)
1104                                 break;
1105                         leaf = path.nodes[0];
1106                         slot = path.slots[0];
1107                 }
1108                 btrfs_item_key_to_cpu(leaf, &key, slot);
1109                 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
1110                         bytes_used += key.offset;
1111                         ret = btrfs_update_block_group(trans, root,
1112                                   key.objectid, key.offset, 1, 0, 1);
1113                         BUG_ON(ret);
1114                 }
1115                 path.slots[0]++;
1116         }
1117         btrfs_set_super_bytes_used(&root->fs_info->super_copy, bytes_used);
1118         btrfs_release_path(root, &path);
1119         return 0;
1120 }
1121
1122 static int init_btrfs(struct btrfs_root *root)
1123 {
1124         int ret;
1125         struct btrfs_key location;
1126         struct btrfs_trans_handle *trans;
1127         struct btrfs_fs_info *fs_info = root->fs_info;
1128
1129         trans = btrfs_start_transaction(root, 1);
1130         BUG_ON(!trans);
1131         ret = btrfs_make_block_groups(trans, root);
1132         if (ret)
1133                 goto err;
1134         ret = fixup_block_accounting(trans, root);
1135         if (ret)
1136                 goto err;
1137         ret = btrfs_make_root_dir(trans, fs_info->tree_root,
1138                                   BTRFS_ROOT_TREE_DIR_OBJECTID);
1139         if (ret)
1140                 goto err;
1141         memcpy(&location, &root->root_key, sizeof(location));
1142         location.offset = (u64)-1;
1143         ret = btrfs_insert_dir_item(trans, fs_info->tree_root, "default", 7,
1144                                 btrfs_super_root_dir(&fs_info->super_copy),
1145                                 &location, BTRFS_FT_DIR);
1146         if (ret)
1147                 goto err;
1148         ret = btrfs_insert_inode_ref(trans, fs_info->tree_root, "default", 7,
1149                                 location.objectid,
1150                                 btrfs_super_root_dir(&fs_info->super_copy));
1151         if (ret)
1152                 goto err;
1153         btrfs_set_root_dirid(&fs_info->fs_root->root_item,
1154                              BTRFS_FIRST_FREE_OBJECTID);
1155         ret = btrfs_commit_transaction(trans, root);
1156         BUG_ON(ret);
1157 err:
1158         return ret;
1159 }
1160 /*
1161  * Migrate super block to it's default position and zero 0 ~ 16k
1162  */
1163 static int migrate_super_block(int fd, u64 old_bytenr, u32 sectorsize)
1164 {
1165         int ret;
1166         char *buf;
1167         u64 bytenr;
1168         u32 crc =  ~(u32)0;
1169         u32 len = 512 - BTRFS_CSUM_SIZE;
1170         struct btrfs_super_block *super;
1171
1172         ret = fsync(fd);
1173         if (ret)
1174                 goto fail;
1175
1176         BUG_ON(sectorsize < sizeof(super));
1177         buf = malloc(sectorsize);
1178         if (!buf)
1179                 return -ENOMEM;
1180         ret = pread(fd, buf, sectorsize, old_bytenr);
1181         if (ret != sectorsize)
1182                 goto fail;
1183
1184         super = (struct btrfs_super_block *)buf;
1185         BUG_ON(btrfs_super_bytenr(super) != old_bytenr);
1186         btrfs_set_super_bytenr(super, BTRFS_SUPER_INFO_OFFSET);
1187
1188         crc = crc32c(crc, buf + BTRFS_CSUM_SIZE, len);
1189         crc = ~cpu_to_le32(crc);
1190         memcpy(super->csum, &crc, BTRFS_CRC32_SIZE);
1191
1192         ret = pwrite(fd, buf, sectorsize, BTRFS_SUPER_INFO_OFFSET);
1193         if (ret < 0)
1194                 goto fail;
1195         /* How to handle this case? */
1196         BUG_ON(ret != sectorsize);
1197
1198         ret = fsync(fd);
1199         if (ret)
1200                 goto fail;
1201
1202         memset(buf, 0, sectorsize);
1203         for (bytenr = 0; bytenr < BTRFS_SUPER_INFO_OFFSET; ) {
1204                 len = BTRFS_SUPER_INFO_OFFSET - bytenr;
1205                 if (len > sectorsize)
1206                         len = sectorsize;
1207                 ret = pwrite(fd, buf, len, bytenr);
1208                 if (ret != len) {
1209                         fprintf(stderr, "unable to zero fill device\n");
1210                         break;
1211                 }
1212                 bytenr += len;
1213         }
1214         ret = 0;
1215         fsync(fd);
1216 fail:
1217         free(buf);
1218         if (ret > 0)
1219                 ret = -1;
1220         return ret;
1221 }
1222 int do_convert(const char *devname, int datacsum)
1223 {
1224         int i, fd, ret;
1225         u32 blocksize;
1226         u64 blocks[4];
1227         u64 total_bytes;
1228         u64 super_bytenr;
1229         ext2_filsys ext2_fs;
1230         struct btrfs_root *root;
1231         struct btrfs_root *ext2_root;
1232
1233         ret = open_ext2fs(devname, &ext2_fs);
1234         if (ret) {
1235                 fprintf(stderr, "unable to open the Ext2fs\n");
1236                 goto fail;
1237         }
1238         blocksize = ext2_fs->blocksize;
1239         total_bytes = (u64)ext2_fs->super->s_blocks_count * blocksize;
1240         if (blocksize < 4096) {
1241                 fprintf(stderr, "block size is too small\n");
1242                 goto fail;
1243         }
1244         if (!(ext2_fs->super->s_feature_incompat &
1245               EXT2_FEATURE_INCOMPAT_FILETYPE)) {
1246                 fprintf(stderr, "filetype feature is missing\n");
1247                 goto fail;
1248         }
1249         for (i = 0; i < 4; i++) {
1250                 ret = ext2_alloc_block(ext2_fs, 0, blocks + i);
1251                 if (ret) {
1252                         fprintf(stderr, "free space isn't enough\n");
1253                         goto fail;
1254                 }
1255                 blocks[i] *= blocksize;
1256         }
1257         super_bytenr = blocks[0];
1258         fd = open(devname, O_RDWR);
1259         if (fd < 0) {
1260                 fprintf(stderr, "unable to open %s\n", devname);
1261                 goto fail;
1262         }
1263         ret = make_btrfs(fd, blocks, total_bytes, blocksize,
1264                          blocksize, blocksize, blocksize);
1265         if (ret) {
1266                 fprintf(stderr, "unable to create initial ctree\n");
1267                 goto fail;
1268         }
1269         root = open_ctree_fd(fd, super_bytenr);
1270         if (!root) {
1271                 fprintf(stderr, "unable to open ctree\n");
1272                 goto fail;
1273         }
1274         fd = dup(fd);
1275         if (fd < 0) {
1276                 fprintf(stderr, "unable to duplicate file descriptor\n");
1277                 goto fail;
1278         }
1279         root->fs_info->priv_data = ext2_fs;
1280         root->fs_info->extent_ops = &extent_ops;
1281         ret = init_btrfs(root);
1282         if (ret) {
1283                 fprintf(stderr, "unable to setup the root tree\n");
1284                 goto fail;
1285         }
1286         ext2_root = create_subvol(root, "ext2_saved");
1287         if (!ext2_root) {
1288                 fprintf(stderr, "unable to create subvol\n");
1289                 goto fail;
1290         }
1291         printf("creating btrfs metadata.\n");
1292         ret = copy_inodes(root, ext2_fs, datacsum);
1293         if (ret) {
1294                 fprintf(stderr, "error during copy_inodes %d\n", ret);
1295                 goto fail;
1296         }
1297         printf("creating ext2fs image file.\n");
1298         ret = create_ext2_image(ext2_root, ext2_fs, "image");
1299         if (ret) {
1300                 fprintf(stderr, "error during create_ext2_image %d\n", ret);
1301                 goto fail;
1302         }
1303         btrfs_free_fs_root(ext2_root->fs_info, ext2_root);
1304         ret = close_ctree(root);
1305         if (ret) {
1306                 fprintf(stderr, "error during close_ctree %d\n", ret);
1307                 goto fail;
1308         }
1309         close_ext2fs(ext2_fs);
1310
1311         /* finally migrate super block to its default postion */
1312         ret = migrate_super_block(fd, super_bytenr, blocksize);
1313         if (ret) {
1314                 fprintf(stderr, "unable to migrate super block\n");
1315                 goto fail;
1316         }
1317         close(fd);
1318         printf("conversion complete.\n");
1319         return 0;
1320 fail:
1321         fprintf(stderr, "conversion aborted.\n");
1322         return -1;
1323 }
1324
1325 int do_rollback(const char *devname, int force)
1326 {
1327         int fd;
1328         int ret;
1329         int modified = 0;
1330         struct btrfs_root *root;
1331         struct btrfs_root *ext2_root;
1332         struct btrfs_dir_item *dir;
1333         struct btrfs_inode_item *inode;
1334         struct btrfs_file_extent_item *fi;
1335         struct btrfs_inode_timespec *tspec;
1336         struct extent_buffer *leaf;
1337         struct btrfs_key key;
1338         struct btrfs_path path;
1339         char *buf;
1340         char *name;
1341         u64 bytenr;
1342         u64 num_bytes;
1343         u64 root_dir;
1344         u64 objectid;
1345         u64 offset;
1346         u64 first_free;
1347         u64 last_trans;
1348         u64 total_bytes;
1349
1350         fd = open(devname, O_RDWR);
1351         if (fd < 0) {
1352                 fprintf(stderr, "unable to open %s\n", devname);
1353                 goto fail;
1354         }
1355         root = open_ctree_fd(fd, 0);
1356         if (!root) {
1357                 fprintf(stderr, "unable to open ctree\n");
1358                 goto fail;
1359         }
1360         fd = dup(fd);
1361         if (fd < 0) {
1362                 fprintf(stderr, "unable to duplicate file descriptor\n");
1363                 goto fail;
1364         }
1365
1366         first_free = BTRFS_SUPER_INFO_OFFSET + root->sectorsize * 2 - 1;
1367         first_free &= ~((u64)root->sectorsize - 1);
1368         buf = malloc(first_free);
1369         if (!buf) {
1370                 fprintf(stderr, "unable to allocate memory\n");
1371                 goto fail;
1372         }
1373
1374         btrfs_init_path(&path);
1375         name = "ext2_saved";
1376         root_dir = btrfs_super_root_dir(&root->fs_info->super_copy);
1377         dir = btrfs_lookup_dir_item(NULL, root->fs_info->tree_root, &path,
1378                                    root_dir, name, strlen(name), 0);
1379         if (!dir || IS_ERR(dir)) {
1380                 fprintf(stderr, "unable to find subvol %s\n", name);
1381                 goto fail;
1382         }
1383         leaf = path.nodes[0];
1384         btrfs_dir_item_key_to_cpu(leaf, dir, &key);
1385         btrfs_release_path(root->fs_info->tree_root, &path);
1386
1387         ext2_root = btrfs_read_fs_root(root->fs_info, &key);
1388         if (!ext2_root || IS_ERR(ext2_root)) {
1389                 fprintf(stderr, "unable to open subvol %s\n", name);
1390                 goto fail;
1391         }
1392
1393         name = "image";
1394         root_dir = btrfs_root_dirid(&root->root_item);
1395         dir = btrfs_lookup_dir_item(NULL, ext2_root, &path,
1396                                    root_dir, name, strlen(name), 0);
1397         if (!dir || IS_ERR(dir)) {
1398                 fprintf(stderr, "unable to find file %s\n", name);
1399                 goto fail;
1400         }
1401         leaf = path.nodes[0];
1402         btrfs_dir_item_key_to_cpu(leaf, dir, &key);
1403         btrfs_release_path(ext2_root, &path);
1404
1405         objectid = key.objectid;
1406
1407         ret = btrfs_lookup_inode(NULL, ext2_root, &path, &key, 0);
1408         if (ret) {
1409                 fprintf(stderr, "unable to find inode item\n");
1410                 goto fail;
1411         }
1412         leaf = path.nodes[0];
1413         inode = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_inode_item);
1414         tspec = btrfs_inode_otime(inode);
1415         /*
1416          * get image file size and transaction id stored in 'otime' field.
1417          * see comments in create_ext2_image.
1418          */
1419         last_trans = btrfs_timespec_sec(leaf, tspec);
1420         total_bytes = btrfs_timespec_nsec(leaf, tspec);
1421         total_bytes *= root->sectorsize;
1422         btrfs_release_path(ext2_root, &path);
1423         if (total_bytes != btrfs_inode_size(leaf, inode)) {
1424                 fprintf(stderr, "image file size mismatch\n");
1425                 goto fail;
1426         }
1427
1428         key.objectid = objectid;
1429         key.offset = 0;
1430         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
1431         ret = btrfs_search_slot(NULL, ext2_root, &key, &path, 0, 0);
1432         if (ret != 0) {
1433                 fprintf(stderr, "unable to find first file extent\n");
1434                 goto fail;
1435         }
1436
1437         for (offset = 0; offset < total_bytes; ) {
1438                 leaf = path.nodes[0];
1439                 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1440                         ret = btrfs_next_leaf(root, &path);
1441                         if (ret != 0)
1442                                 break;
1443                         continue;
1444                 }
1445
1446                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1447                 if (key.objectid != objectid || key.offset != offset ||
1448                     btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
1449                         break;
1450
1451                 fi = btrfs_item_ptr(leaf, path.slots[0],
1452                                     struct btrfs_file_extent_item);
1453                 if (btrfs_file_extent_generation(leaf, fi) > last_trans) {
1454                         modified = 1;
1455                         break;
1456                 }
1457                 if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
1458                         break;
1459
1460                 if (offset >= first_free)
1461                         goto next;
1462
1463                 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1464                 if (bytenr == 0)
1465                         break;
1466                 bytenr += btrfs_file_extent_offset(leaf, fi);
1467                 num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
1468                 if (num_bytes > first_free - offset)
1469                         num_bytes = first_free - offset;
1470
1471                 ret = pread(fd, buf + offset, num_bytes, bytenr);
1472                 if (ret != num_bytes) {
1473                         fprintf(stderr, "unable to read required data\n");
1474                         btrfs_release_path(ext2_root, &path);
1475                         goto fail;
1476                 }
1477 next:
1478                 offset += btrfs_file_extent_num_bytes(leaf, fi);
1479                 path.slots[0]++;
1480         }
1481         btrfs_release_path(ext2_root, &path);
1482
1483         if (modified) {
1484                 fprintf(stderr, "image file has been modified\n");
1485                 goto fail;
1486         }
1487         if (offset < total_bytes) {
1488                 fprintf(stderr, "unable to check all file extents\n");
1489                 goto fail;
1490         }
1491
1492         btrfs_free_fs_root(ext2_root->fs_info, ext2_root);
1493         ret = close_ctree(root);
1494         if (ret) {
1495                 fprintf(stderr, "error during close_ctree %d\n", ret);
1496                 goto fail;
1497         }
1498
1499         ret = pwrite(fd, buf, first_free, 0);
1500         if (ret < 0) {
1501                 fprintf(stderr, "error during pwrite %d\n", ret);
1502                 goto fail;
1503         }
1504         /* How to handle this case? */
1505         BUG_ON(ret != first_free);
1506         ret = fsync(fd);
1507         if (ret) {
1508                 fprintf(stderr, "error during fsync %d\n", ret);
1509                 goto fail;
1510         }
1511         close(fd);
1512         free(buf);
1513         printf("rollback complete.\n");
1514         return 0;
1515 fail:
1516         fprintf(stderr, "rollback aborted.\n");
1517         return -1;
1518 }
1519
1520 static void print_usage(void)
1521 {
1522         printf("usage: btrfs-convert [-d] [-r] device\n");
1523         printf("\t-d disable data checksum\n");
1524         printf("\t-r roll back to ext2fs\n");
1525         exit(1);
1526 }
1527
1528 int main(int argc, char *argv[])
1529 {
1530         int ret;
1531         int datacsum = 1;
1532         int rollback = 0;
1533         char *file;
1534
1535         while(1) {
1536                 int c = getopt(argc, argv, "dr");
1537                 if (c < 0)
1538                         break;
1539                 switch(c) {
1540                         case 'd':
1541                                 datacsum = 0;
1542                                 break;
1543                         case 'r':
1544                                 rollback = 1;
1545                                 break;
1546                         default:
1547                                 print_usage();
1548                 }
1549         }
1550         argc = argc - optind;
1551         if (argc == 1) {
1552                 file = argv[optind];
1553         } else {
1554                 print_usage();
1555         }
1556         if (rollback) {
1557                 ret = do_rollback(file, 0);
1558         } else {
1559                 ret = do_convert(file, datacsum);
1560         }
1561         return ret;
1562 }