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