convert/source-ext2.c

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public
   4  * License v2 as published by the Free Software Foundation.
   5  *
   6  * This program is distributed in the hope that it will be useful,
   7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   9  * General Public License for more details.
  10  *
  11  * You should have received a copy of the GNU General Public
  12  * License along with this program; if not, write to the
  13  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  14  * Boston, MA 021110-1307, USA.
  15  */
  16
  17 #if BTRFSCONVERT_EXT2
  18
  19 #include "kerncompat.h"
  20 #include "disk-io.h"
  21 #include "transaction.h"
  22 #include "utils.h"
  23 #include "convert/common.h"
  24 #include "convert/source-ext2.h"
  25
  26 /*
  27  * Open Ext2fs in readonly mode, read block allocation bitmap and
  28  * inode bitmap into memory.
  29  */
  30 static int ext2_open_fs(struct btrfs_convert_context *cctx, const char *name)
  31 {
  32         errcode_t ret;
  33         ext2_filsys ext2_fs;
  34         ext2_ino_t ino;
  35         u32 ro_feature;
  36
  37         ret = ext2fs_open(name, 0, 0, 0, unix_io_manager, &ext2_fs);
  38         if (ret) {
  39                 fprintf(stderr, "ext2fs_open: %s\n", error_message(ret));
  40                 return -1;
  41         }
  42         /*
  43          * We need to know exactly the used space, some RO compat flags like
  44          * BIGALLOC will affect how used space is present.
  45          * So we need manuall check any unsupported RO compat flags
  46          */
  47         ro_feature = ext2_fs->super->s_feature_ro_compat;
  48         if (ro_feature & ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP) {
  49                 error(
  50 "unsupported RO features detected: %x, abort convert to avoid possible corruption",
  51                       ro_feature & ~EXT2_LIB_FEATURE_COMPAT_SUPP);
  52                 goto fail;
  53         }
  54         ret = ext2fs_read_inode_bitmap(ext2_fs);
  55         if (ret) {
  56                 fprintf(stderr, "ext2fs_read_inode_bitmap: %s\n",
  57                         error_message(ret));
  58                 goto fail;
  59         }
  60         ret = ext2fs_read_block_bitmap(ext2_fs);
  61         if (ret) {
  62                 fprintf(stderr, "ext2fs_read_block_bitmap: %s\n",
  63                         error_message(ret));
  64                 goto fail;
  65         }
  66         /*
  67          * search each block group for a free inode. this set up
  68          * uninit block/inode bitmaps appropriately.
  69          */
  70         ino = 1;
  71         while (ino <= ext2_fs->super->s_inodes_count) {
  72                 ext2_ino_t foo;
  73                 ext2fs_new_inode(ext2_fs, ino, 0, NULL, &foo);
  74                 ino += EXT2_INODES_PER_GROUP(ext2_fs->super);
  75         }
  76
  77         if (!(ext2_fs->super->s_feature_incompat &
  78               EXT2_FEATURE_INCOMPAT_FILETYPE)) {
  79                 error("filetype feature is missing");
  80                 goto fail;
  81         }
  82
  83         cctx->fs_data = ext2_fs;
  84         cctx->blocksize = ext2_fs->blocksize;
  85         cctx->block_count = ext2_fs->super->s_blocks_count;
  86         cctx->total_bytes = ext2_fs->blocksize * ext2_fs->super->s_blocks_count;
  87         cctx->volume_name = strndup(ext2_fs->super->s_volume_name, 16);
  88         cctx->first_data_block = ext2_fs->super->s_first_data_block;
  89         cctx->inodes_count = ext2_fs->super->s_inodes_count;
  90         cctx->free_inodes_count = ext2_fs->super->s_free_inodes_count;
  91         return 0;
  92 fail:
  93         ext2fs_close(ext2_fs);
  94         return -1;
  95 }
  96
  97 static int __ext2_add_one_block(ext2_filsys fs, char *bitmap,
  98                                 unsigned long group_nr, struct cache_tree *used)
  99 {
 100         unsigned long offset;
 101         unsigned i;
 102         int ret = 0;
 103
 104         offset = fs->super->s_first_data_block;
 105         offset /= EXT2FS_CLUSTER_RATIO(fs);
 106         offset += group_nr * EXT2_CLUSTERS_PER_GROUP(fs->super);
 107         for (i = 0; i < EXT2_CLUSTERS_PER_GROUP(fs->super); i++) {
 108                 if ((i + offset) >= ext2fs_blocks_count(fs->super))
 109                         break;
 110
 111                 if (ext2fs_test_bit(i, bitmap)) {
 112                         u64 start;
 113
 114                         start = (i + offset) * EXT2FS_CLUSTER_RATIO(fs);
 115                         start *= fs->blocksize;
 116                         ret = add_merge_cache_extent(used, start,
 117                                                      fs->blocksize);
 118                         if (ret < 0)
 119                                 break;
 120                 }
 121         }
 122         return ret;
 123 }
 124
 125 /*
 126  * Read all used ext2 space into cctx->used cache tree
 127  */
 128 static int ext2_read_used_space(struct btrfs_convert_context *cctx)
 129 {
 130         ext2_filsys fs = (ext2_filsys)cctx->fs_data;
 131         blk64_t blk_itr = EXT2FS_B2C(fs, fs->super->s_first_data_block);
 132         struct cache_tree *used_tree = &cctx->used;
 133         char *block_bitmap = NULL;
 134         unsigned long i;
 135         int block_nbytes;
 136         int ret = 0;
 137
 138         block_nbytes = EXT2_CLUSTERS_PER_GROUP(fs->super) / 8;
 139         if (!block_nbytes) {
 140                 error("EXT2_CLUSTERS_PER_GROUP too small: %llu",
 141                         (unsigned long long)(EXT2_CLUSTERS_PER_GROUP(fs->super)));
 142                 return -EINVAL;
 143         }
 144
 145         block_bitmap = malloc(block_nbytes);
 146         if (!block_bitmap)
 147                 return -ENOMEM;
 148
 149         for (i = 0; i < fs->group_desc_count; i++) {
 150                 ret = ext2fs_get_block_bitmap_range(fs->block_map, blk_itr,
 151                                                 block_nbytes * 8, block_bitmap);
 152                 if (ret) {
 153                         error("fail to get bitmap from ext2, %s",
 154                               strerror(-ret));
 155                         break;
 156                 }
 157                 ret = __ext2_add_one_block(fs, block_bitmap, i, used_tree);
 158                 if (ret < 0) {
 159                         error("fail to build used space tree, %s",
 160                               strerror(-ret));
 161                         break;
 162                 }
 163                 blk_itr += EXT2_CLUSTERS_PER_GROUP(fs->super);
 164         }
 165
 166         free(block_bitmap);
 167         return ret;
 168 }
 169
 170 static void ext2_close_fs(struct btrfs_convert_context *cctx)
 171 {
 172         if (cctx->volume_name) {
 173                 free(cctx->volume_name);
 174                 cctx->volume_name = NULL;
 175         }
 176         ext2fs_close(cctx->fs_data);
 177 }
 178
 179 static u8 ext2_filetype_conversion_table[EXT2_FT_MAX] = {
 180         [EXT2_FT_UNKNOWN]       = BTRFS_FT_UNKNOWN,
 181         [EXT2_FT_REG_FILE]      = BTRFS_FT_REG_FILE,
 182         [EXT2_FT_DIR]           = BTRFS_FT_DIR,
 183         [EXT2_FT_CHRDEV]        = BTRFS_FT_CHRDEV,
 184         [EXT2_FT_BLKDEV]        = BTRFS_FT_BLKDEV,
 185         [EXT2_FT_FIFO]          = BTRFS_FT_FIFO,
 186         [EXT2_FT_SOCK]          = BTRFS_FT_SOCK,
 187         [EXT2_FT_SYMLINK]       = BTRFS_FT_SYMLINK,
 188 };
 189
 190 static int ext2_dir_iterate_proc(ext2_ino_t dir, int entry,
 191                             struct ext2_dir_entry *dirent,
 192                             int offset, int blocksize,
 193                             char *buf,void *priv_data)
 194 {
 195         int ret;
 196         int file_type;
 197         u64 objectid;
 198         char dotdot[] = "..";
 199         struct dir_iterate_data *idata = (struct dir_iterate_data *)priv_data;
 200         int name_len;
 201
 202         name_len = dirent->name_len & 0xFF;
 203
 204         objectid = dirent->inode + INO_OFFSET;
 205         if (!strncmp(dirent->name, dotdot, name_len)) {
 206                 if (name_len == 2) {
 207                         BUG_ON(idata->parent != 0);
 208                         idata->parent = objectid;
 209                 }
 210                 return 0;
 211         }
 212         if (dirent->inode < EXT2_GOOD_OLD_FIRST_INO)
 213                 return 0;
 214
 215         file_type = dirent->name_len >> 8;
 216         BUG_ON(file_type > EXT2_FT_SYMLINK);
 217
 218         ret = convert_insert_dirent(idata->trans, idata->root, dirent->name,
 219                                     name_len, idata->objectid, objectid,
 220                                     ext2_filetype_conversion_table[file_type],
 221                                     idata->index_cnt, idata->inode);
 222         if (ret < 0) {
 223                 idata->errcode = ret;
 224                 return BLOCK_ABORT;
 225         }
 226
 227         idata->index_cnt++;
 228         return 0;
 229 }
 230
 231 static int ext2_create_dir_entries(struct btrfs_trans_handle *trans,
 232                               struct btrfs_root *root, u64 objectid,
 233                               struct btrfs_inode_item *btrfs_inode,
 234                               ext2_filsys ext2_fs, ext2_ino_t ext2_ino)
 235 {
 236         int ret;
 237         errcode_t err;
 238         struct dir_iterate_data data = {
 239                 .trans          = trans,
 240                 .root           = root,
 241                 .inode          = btrfs_inode,
 242                 .objectid       = objectid,
 243                 .index_cnt      = 2,
 244                 .parent         = 0,
 245                 .errcode        = 0,
 246         };
 247
 248         err = ext2fs_dir_iterate2(ext2_fs, ext2_ino, 0, NULL,
 249                                   ext2_dir_iterate_proc, &data);
 250         if (err)
 251                 goto error;
 252         ret = data.errcode;
 253         if (ret == 0 && data.parent == objectid) {
 254                 ret = btrfs_insert_inode_ref(trans, root, "..", 2,
 255                                              objectid, objectid, 0);
 256         }
 257         return ret;
 258 error:
 259         fprintf(stderr, "ext2fs_dir_iterate2: %s\n", error_message(err));
 260         return -1;
 261 }
 262
 263 static int ext2_block_iterate_proc(ext2_filsys fs, blk_t *blocknr,
 264                                 e2_blkcnt_t blockcnt, blk_t ref_block,
 265                                 int ref_offset, void *priv_data)
 266 {
 267         int ret;
 268         struct blk_iterate_data *idata;
 269         idata = (struct blk_iterate_data *)priv_data;
 270         ret = block_iterate_proc(*blocknr, blockcnt, idata);
 271         if (ret) {
 272                 idata->errcode = ret;
 273                 return BLOCK_ABORT;
 274         }
 275         return 0;
 276 }
 277
 278 /*
 279  * traverse file's data blocks, record these data blocks as file extents.
 280  */
 281 static int ext2_create_file_extents(struct btrfs_trans_handle *trans,
 282                                struct btrfs_root *root, u64 objectid,
 283                                struct btrfs_inode_item *btrfs_inode,
 284                                ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
 285                                int datacsum, int packing)
 286 {
 287         int ret;
 288         char *buffer = NULL;
 289         errcode_t err;
 290         u32 last_block;
 291         u32 sectorsize = root->sectorsize;
 292         u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
 293         struct blk_iterate_data data;
 294
 295         init_blk_iterate_data(&data, trans, root, btrfs_inode, objectid,
 296                               datacsum);
 297
 298         err = ext2fs_block_iterate2(ext2_fs, ext2_ino, BLOCK_FLAG_DATA_ONLY,
 299                                     NULL, ext2_block_iterate_proc, &data);
 300         if (err)
 301                 goto error;
 302         ret = data.errcode;
 303         if (ret)
 304                 goto fail;
 305         if (packing && data.first_block == 0 && data.num_blocks > 0 &&
 306             inode_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
 307                 u64 num_bytes = data.num_blocks * sectorsize;
 308                 u64 disk_bytenr = data.disk_block * sectorsize;
 309                 u64 nbytes;
 310
 311                 buffer = malloc(num_bytes);
 312                 if (!buffer)
 313                         return -ENOMEM;
 314                 ret = read_disk_extent(root, disk_bytenr, num_bytes, buffer);
 315                 if (ret)
 316                         goto fail;
 317                 if (num_bytes > inode_size)
 318                         num_bytes = inode_size;
 319                 ret = btrfs_insert_inline_extent(trans, root, objectid,
 320                                                  0, buffer, num_bytes);
 321                 if (ret)
 322                         goto fail;
 323                 nbytes = btrfs_stack_inode_nbytes(btrfs_inode) + num_bytes;
 324                 btrfs_set_stack_inode_nbytes(btrfs_inode, nbytes);
 325         } else if (data.num_blocks > 0) {
 326                 ret = record_file_blocks(&data, data.first_block,
 327                                          data.disk_block, data.num_blocks);
 328                 if (ret)
 329                         goto fail;
 330         }
 331         data.first_block += data.num_blocks;
 332         last_block = (inode_size + sectorsize - 1) / sectorsize;
 333         if (last_block > data.first_block) {
 334                 ret = record_file_blocks(&data, data.first_block, 0,
 335                                          last_block - data.first_block);
 336         }
 337 fail:
 338         free(buffer);
 339         return ret;
 340 error:
 341         fprintf(stderr, "ext2fs_block_iterate2: %s\n", error_message(err));
 342         return -1;
 343 }
 344
 345 static int ext2_create_symbol_link(struct btrfs_trans_handle *trans,
 346                               struct btrfs_root *root, u64 objectid,
 347                               struct btrfs_inode_item *btrfs_inode,
 348                               ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
 349                               struct ext2_inode *ext2_inode)
 350 {
 351         int ret;
 352         char *pathname;
 353         u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
 354         if (ext2fs_inode_data_blocks(ext2_fs, ext2_inode)) {
 355                 btrfs_set_stack_inode_size(btrfs_inode, inode_size + 1);
 356                 ret = ext2_create_file_extents(trans, root, objectid,
 357                                 btrfs_inode, ext2_fs, ext2_ino, 1, 1);
 358                 btrfs_set_stack_inode_size(btrfs_inode, inode_size);
 359                 return ret;
 360         }
 361
 362         pathname = (char *)&(ext2_inode->i_block[0]);
 363         BUG_ON(pathname[inode_size] != 0);
 364         ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
 365                                          pathname, inode_size + 1);
 366         btrfs_set_stack_inode_nbytes(btrfs_inode, inode_size + 1);
 367         return ret;
 368 }
 369
 370 /*
 371  * Following xattr/acl related codes are based on codes in
 372  * fs/ext3/xattr.c and fs/ext3/acl.c
 373  */
 374 #define EXT2_XATTR_BHDR(ptr) ((struct ext2_ext_attr_header *)(ptr))
 375 #define EXT2_XATTR_BFIRST(ptr) \
 376         ((struct ext2_ext_attr_entry *)(EXT2_XATTR_BHDR(ptr) + 1))
 377 #define EXT2_XATTR_IHDR(inode) \
 378         ((struct ext2_ext_attr_header *) ((void *)(inode) + \
 379                 EXT2_GOOD_OLD_INODE_SIZE + (inode)->i_extra_isize))
 380 #define EXT2_XATTR_IFIRST(inode) \
 381         ((struct ext2_ext_attr_entry *) ((void *)EXT2_XATTR_IHDR(inode) + \
 382                 sizeof(EXT2_XATTR_IHDR(inode)->h_magic)))
 383
 384 static int ext2_xattr_check_names(struct ext2_ext_attr_entry *entry,
 385                                   const void *end)
 386 {
 387         struct ext2_ext_attr_entry *next;
 388
 389         while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
 390                 next = EXT2_EXT_ATTR_NEXT(entry);
 391                 if ((void *)next >= end)
 392                         return -EIO;
 393                 entry = next;
 394         }
 395         return 0;
 396 }
 397
 398 static int ext2_xattr_check_block(const char *buf, size_t size)
 399 {
 400         int error;
 401         struct ext2_ext_attr_header *header = EXT2_XATTR_BHDR(buf);
 402
 403         if (header->h_magic != EXT2_EXT_ATTR_MAGIC ||
 404             header->h_blocks != 1)
 405                 return -EIO;
 406         error = ext2_xattr_check_names(EXT2_XATTR_BFIRST(buf), buf + size);
 407         return error;
 408 }
 409
 410 static int ext2_xattr_check_entry(struct ext2_ext_attr_entry *entry,
 411                                   size_t size)
 412 {
 413         size_t value_size = entry->e_value_size;
 414
 415         if (entry->e_value_block != 0 || value_size > size ||
 416             entry->e_value_offs + value_size > size)
 417                 return -EIO;
 418         return 0;
 419 }
 420
 421 static inline int ext2_acl_count(size_t size)
 422 {
 423         ssize_t s;
 424         size -= sizeof(ext2_acl_header);
 425         s = size - 4 * sizeof(ext2_acl_entry_short);
 426         if (s < 0) {
 427                 if (size % sizeof(ext2_acl_entry_short))
 428                         return -1;
 429                 return size / sizeof(ext2_acl_entry_short);
 430         } else {
 431                 if (s % sizeof(ext2_acl_entry))
 432                         return -1;
 433                 return s / sizeof(ext2_acl_entry) + 4;
 434         }
 435 }
 436
 437 static inline size_t acl_ea_size(int count)
 438 {
 439         return sizeof(acl_ea_header) + count * sizeof(acl_ea_entry);
 440 }
 441
 442 static int ext2_acl_to_xattr(void *dst, const void *src,
 443                              size_t dst_size, size_t src_size)
 444 {
 445         int i, count;
 446         const void *end = src + src_size;
 447         acl_ea_header *ext_acl = (acl_ea_header *)dst;
 448         acl_ea_entry *dst_entry = ext_acl->a_entries;
 449         ext2_acl_entry *src_entry;
 450
 451         if (src_size < sizeof(ext2_acl_header))
 452                 goto fail;
 453         if (((ext2_acl_header *)src)->a_version !=
 454             cpu_to_le32(EXT2_ACL_VERSION))
 455                 goto fail;
 456         src += sizeof(ext2_acl_header);
 457         count = ext2_acl_count(src_size);
 458         if (count <= 0)
 459                 goto fail;
 460
 461         BUG_ON(dst_size < acl_ea_size(count));
 462         ext_acl->a_version = cpu_to_le32(ACL_EA_VERSION);
 463         for (i = 0; i < count; i++, dst_entry++) {
 464                 src_entry = (ext2_acl_entry *)src;
 465                 if (src + sizeof(ext2_acl_entry_short) > end)
 466                         goto fail;
 467                 dst_entry->e_tag = src_entry->e_tag;
 468                 dst_entry->e_perm = src_entry->e_perm;
 469                 switch (le16_to_cpu(src_entry->e_tag)) {
 470                 case ACL_USER_OBJ:
 471                 case ACL_GROUP_OBJ:
 472                 case ACL_MASK:
 473                 case ACL_OTHER:
 474                         src += sizeof(ext2_acl_entry_short);
 475                         dst_entry->e_id = cpu_to_le32(ACL_UNDEFINED_ID);
 476                         break;
 477                 case ACL_USER:
 478                 case ACL_GROUP:
 479                         src += sizeof(ext2_acl_entry);
 480                         if (src > end)
 481                                 goto fail;
 482                         dst_entry->e_id = src_entry->e_id;
 483                         break;
 484                 default:
 485                         goto fail;
 486                 }
 487         }
 488         if (src != end)
 489                 goto fail;
 490         return 0;
 491 fail:
 492         return -EINVAL;
 493 }
 494
 495 static char *xattr_prefix_table[] = {
 496         [1] =   "user.",
 497         [2] =   "system.posix_acl_access",
 498         [3] =   "system.posix_acl_default",
 499         [4] =   "trusted.",
 500         [6] =   "security.",
 501 };
 502
 503 static int ext2_copy_single_xattr(struct btrfs_trans_handle *trans,
 504                              struct btrfs_root *root, u64 objectid,
 505                              struct ext2_ext_attr_entry *entry,
 506                              const void *data, u32 datalen)
 507 {
 508         int ret = 0;
 509         int name_len;
 510         int name_index;
 511         void *databuf = NULL;
 512         char namebuf[XATTR_NAME_MAX + 1];
 513
 514         name_index = entry->e_name_index;
 515         if (name_index >= ARRAY_SIZE(xattr_prefix_table) ||
 516             xattr_prefix_table[name_index] == NULL)
 517                 return -EOPNOTSUPP;
 518         name_len = strlen(xattr_prefix_table[name_index]) +
 519                    entry->e_name_len;
 520         if (name_len >= sizeof(namebuf))
 521                 return -ERANGE;
 522
 523         if (name_index == 2 || name_index == 3) {
 524                 size_t bufsize = acl_ea_size(ext2_acl_count(datalen));
 525                 databuf = malloc(bufsize);
 526                 if (!databuf)
 527                        return -ENOMEM;
 528                 ret = ext2_acl_to_xattr(databuf, data, bufsize, datalen);
 529                 if (ret)
 530                         goto out;
 531                 data = databuf;
 532                 datalen = bufsize;
 533         }
 534         strncpy(namebuf, xattr_prefix_table[name_index], XATTR_NAME_MAX);
 535         strncat(namebuf, EXT2_EXT_ATTR_NAME(entry), entry->e_name_len);
 536         if (name_len + datalen > BTRFS_LEAF_DATA_SIZE(root) -
 537             sizeof(struct btrfs_item) - sizeof(struct btrfs_dir_item)) {
 538                 fprintf(stderr, "skip large xattr on inode %Lu name %.*s\n",
 539                         objectid - INO_OFFSET, name_len, namebuf);
 540                 goto out;
 541         }
 542         ret = btrfs_insert_xattr_item(trans, root, namebuf, name_len,
 543                                       data, datalen, objectid);
 544 out:
 545         free(databuf);
 546         return ret;
 547 }
 548
 549 static int ext2_copy_extended_attrs(struct btrfs_trans_handle *trans,
 550                                struct btrfs_root *root, u64 objectid,
 551                                struct btrfs_inode_item *btrfs_inode,
 552                                ext2_filsys ext2_fs, ext2_ino_t ext2_ino)
 553 {
 554         int ret = 0;
 555         int inline_ea = 0;
 556         errcode_t err;
 557         u32 datalen;
 558         u32 block_size = ext2_fs->blocksize;
 559         u32 inode_size = EXT2_INODE_SIZE(ext2_fs->super);
 560         struct ext2_inode_large *ext2_inode;
 561         struct ext2_ext_attr_entry *entry;
 562         void *data;
 563         char *buffer = NULL;
 564         char inode_buf[EXT2_GOOD_OLD_INODE_SIZE];
 565
 566         if (inode_size <= EXT2_GOOD_OLD_INODE_SIZE) {
 567                 ext2_inode = (struct ext2_inode_large *)inode_buf;
 568         } else {
 569                 ext2_inode = (struct ext2_inode_large *)malloc(inode_size);
 570                 if (!ext2_inode)
 571                        return -ENOMEM;
 572         }
 573         err = ext2fs_read_inode_full(ext2_fs, ext2_ino, (void *)ext2_inode,
 574                                      inode_size);
 575         if (err) {
 576                 fprintf(stderr, "ext2fs_read_inode_full: %s\n",
 577                         error_message(err));
 578                 ret = -1;
 579                 goto out;
 580         }
 581
 582         if (ext2_ino > ext2_fs->super->s_first_ino &&
 583             inode_size > EXT2_GOOD_OLD_INODE_SIZE) {
 584                 if (EXT2_GOOD_OLD_INODE_SIZE +
 585                     ext2_inode->i_extra_isize > inode_size) {
 586                         ret = -EIO;
 587                         goto out;
 588                 }
 589                 if (ext2_inode->i_extra_isize != 0 &&
 590                     EXT2_XATTR_IHDR(ext2_inode)->h_magic ==
 591                     EXT2_EXT_ATTR_MAGIC) {
 592                         inline_ea = 1;
 593                 }
 594         }
 595         if (inline_ea) {
 596                 int total;
 597                 void *end = (void *)ext2_inode + inode_size;
 598                 entry = EXT2_XATTR_IFIRST(ext2_inode);
 599                 total = end - (void *)entry;
 600                 ret = ext2_xattr_check_names(entry, end);
 601                 if (ret)
 602                         goto out;
 603                 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
 604                         ret = ext2_xattr_check_entry(entry, total);
 605                         if (ret)
 606                                 goto out;
 607                         data = (void *)EXT2_XATTR_IFIRST(ext2_inode) +
 608                                 entry->e_value_offs;
 609                         datalen = entry->e_value_size;
 610                         ret = ext2_copy_single_xattr(trans, root, objectid,
 611                                                 entry, data, datalen);
 612                         if (ret)
 613                                 goto out;
 614                         entry = EXT2_EXT_ATTR_NEXT(entry);
 615                 }
 616         }
 617
 618         if (ext2_inode->i_file_acl == 0)
 619                 goto out;
 620
 621         buffer = malloc(block_size);
 622         if (!buffer) {
 623                 ret = -ENOMEM;
 624                 goto out;
 625         }
 626         err = ext2fs_read_ext_attr(ext2_fs, ext2_inode->i_file_acl, buffer);
 627         if (err) {
 628                 fprintf(stderr, "ext2fs_read_ext_attr: %s\n",
 629                         error_message(err));
 630                 ret = -1;
 631                 goto out;
 632         }
 633         ret = ext2_xattr_check_block(buffer, block_size);
 634         if (ret)
 635                 goto out;
 636
 637         entry = EXT2_XATTR_BFIRST(buffer);
 638         while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
 639                 ret = ext2_xattr_check_entry(entry, block_size);
 640                 if (ret)
 641                         goto out;
 642                 data = buffer + entry->e_value_offs;
 643                 datalen = entry->e_value_size;
 644                 ret = ext2_copy_single_xattr(trans, root, objectid,
 645                                         entry, data, datalen);
 646                 if (ret)
 647                         goto out;
 648                 entry = EXT2_EXT_ATTR_NEXT(entry);
 649         }
 650 out:
 651         free(buffer);
 652         if ((void *)ext2_inode != inode_buf)
 653                 free(ext2_inode);
 654         return ret;
 655 }
 656 #define MINORBITS       20
 657 #define MKDEV(ma, mi)   (((ma) << MINORBITS) | (mi))
 658
 659 static inline dev_t old_decode_dev(u16 val)
 660 {
 661         return MKDEV((val >> 8) & 255, val & 255);
 662 }
 663
 664 static inline dev_t new_decode_dev(u32 dev)
 665 {
 666         unsigned major = (dev & 0xfff00) >> 8;
 667         unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);
 668         return MKDEV(major, minor);
 669 }
 670
 671 static void ext2_copy_inode_item(struct btrfs_inode_item *dst,
 672                            struct ext2_inode *src, u32 blocksize)
 673 {
 674         btrfs_set_stack_inode_generation(dst, 1);
 675         btrfs_set_stack_inode_sequence(dst, 0);
 676         btrfs_set_stack_inode_transid(dst, 1);
 677         btrfs_set_stack_inode_size(dst, src->i_size);
 678         btrfs_set_stack_inode_nbytes(dst, 0);
 679         btrfs_set_stack_inode_block_group(dst, 0);
 680         btrfs_set_stack_inode_nlink(dst, src->i_links_count);
 681         btrfs_set_stack_inode_uid(dst, src->i_uid | (src->i_uid_high << 16));
 682         btrfs_set_stack_inode_gid(dst, src->i_gid | (src->i_gid_high << 16));
 683         btrfs_set_stack_inode_mode(dst, src->i_mode);
 684         btrfs_set_stack_inode_rdev(dst, 0);
 685         btrfs_set_stack_inode_flags(dst, 0);
 686         btrfs_set_stack_timespec_sec(&dst->atime, src->i_atime);
 687         btrfs_set_stack_timespec_nsec(&dst->atime, 0);
 688         btrfs_set_stack_timespec_sec(&dst->ctime, src->i_ctime);
 689         btrfs_set_stack_timespec_nsec(&dst->ctime, 0);
 690         btrfs_set_stack_timespec_sec(&dst->mtime, src->i_mtime);
 691         btrfs_set_stack_timespec_nsec(&dst->mtime, 0);
 692         btrfs_set_stack_timespec_sec(&dst->otime, 0);
 693         btrfs_set_stack_timespec_nsec(&dst->otime, 0);
 694
 695         if (S_ISDIR(src->i_mode)) {
 696                 btrfs_set_stack_inode_size(dst, 0);
 697                 btrfs_set_stack_inode_nlink(dst, 1);
 698         }
 699         if (S_ISREG(src->i_mode)) {
 700                 btrfs_set_stack_inode_size(dst, (u64)src->i_size_high << 32 |
 701                                            (u64)src->i_size);
 702         }
 703         if (!S_ISREG(src->i_mode) && !S_ISDIR(src->i_mode) &&
 704             !S_ISLNK(src->i_mode)) {
 705                 if (src->i_block[0]) {
 706                         btrfs_set_stack_inode_rdev(dst,
 707                                 old_decode_dev(src->i_block[0]));
 708                 } else {
 709                         btrfs_set_stack_inode_rdev(dst,
 710                                 new_decode_dev(src->i_block[1]));
 711                 }
 712         }
 713         memset(&dst->reserved, 0, sizeof(dst->reserved));
 714 }
 715 static int ext2_check_state(struct btrfs_convert_context *cctx)
 716 {
 717         ext2_filsys fs = cctx->fs_data;
 718
 719         if (!(fs->super->s_state & EXT2_VALID_FS))
 720                 return 1;
 721         else if (fs->super->s_state & EXT2_ERROR_FS)
 722                 return 1;
 723         else
 724                 return 0;
 725 }
 726
 727 /* EXT2_*_FL to BTRFS_INODE_FLAG_* stringification helper */
 728 #define COPY_ONE_EXT2_FLAG(flags, ext2_inode, name) ({                  \
 729         if (ext2_inode->i_flags & EXT2_##name##_FL)                     \
 730                 flags |= BTRFS_INODE_##name;                            \
 731 })
 732
 733 /*
 734  * Convert EXT2_*_FL to corresponding BTRFS_INODE_* flags
 735  *
 736  * Only a subset of EXT_*_FL is supported in btrfs.
 737  */
 738 static void ext2_convert_inode_flags(struct btrfs_inode_item *dst,
 739                                      struct ext2_inode *src)
 740 {
 741         u64 flags = 0;
 742
 743         COPY_ONE_EXT2_FLAG(flags, src, APPEND);
 744         COPY_ONE_EXT2_FLAG(flags, src, SYNC);
 745         COPY_ONE_EXT2_FLAG(flags, src, IMMUTABLE);
 746         COPY_ONE_EXT2_FLAG(flags, src, NODUMP);
 747         COPY_ONE_EXT2_FLAG(flags, src, NOATIME);
 748         COPY_ONE_EXT2_FLAG(flags, src, DIRSYNC);
 749         btrfs_set_stack_inode_flags(dst, flags);
 750 }
 751
 752 /*
 753  * copy a single inode. do all the required works, such as cloning
 754  * inode item, creating file extents and creating directory entries.
 755  */
 756 static int ext2_copy_single_inode(struct btrfs_trans_handle *trans,
 757                              struct btrfs_root *root, u64 objectid,
 758                              ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
 759                              struct ext2_inode *ext2_inode,
 760                              int datacsum, int packing, int noxattr)
 761 {
 762         int ret;
 763         struct btrfs_inode_item btrfs_inode;
 764
 765         if (ext2_inode->i_links_count == 0)
 766                 return 0;
 767
 768         ext2_copy_inode_item(&btrfs_inode, ext2_inode, ext2_fs->blocksize);
 769         if (!datacsum && S_ISREG(ext2_inode->i_mode)) {
 770                 u32 flags = btrfs_stack_inode_flags(&btrfs_inode) |
 771                             BTRFS_INODE_NODATASUM;
 772                 btrfs_set_stack_inode_flags(&btrfs_inode, flags);
 773         }
 774         ext2_convert_inode_flags(&btrfs_inode, ext2_inode);
 775
 776         switch (ext2_inode->i_mode & S_IFMT) {
 777         case S_IFREG:
 778                 ret = ext2_create_file_extents(trans, root, objectid,
 779                         &btrfs_inode, ext2_fs, ext2_ino, datacsum, packing);
 780                 break;
 781         case S_IFDIR:
 782                 ret = ext2_create_dir_entries(trans, root, objectid,
 783                                 &btrfs_inode, ext2_fs, ext2_ino);
 784                 break;
 785         case S_IFLNK:
 786                 ret = ext2_create_symbol_link(trans, root, objectid,
 787                                 &btrfs_inode, ext2_fs, ext2_ino, ext2_inode);
 788                 break;
 789         default:
 790                 ret = 0;
 791                 break;
 792         }
 793         if (ret)
 794                 return ret;
 795
 796         if (!noxattr) {
 797                 ret = ext2_copy_extended_attrs(trans, root, objectid,
 798                                 &btrfs_inode, ext2_fs, ext2_ino);
 799                 if (ret)
 800                         return ret;
 801         }
 802         return btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
 803 }
 804
 805 /*
 806  * scan ext2's inode bitmap and copy all used inodes.
 807  */
 808 static int ext2_copy_inodes(struct btrfs_convert_context *cctx,
 809                             struct btrfs_root *root,
 810                             int datacsum, int packing, int noxattr, struct task_ctx *p)
 811 {
 812         ext2_filsys ext2_fs = cctx->fs_data;
 813         int ret;
 814         errcode_t err;
 815         ext2_inode_scan ext2_scan;
 816         struct ext2_inode ext2_inode;
 817         ext2_ino_t ext2_ino;
 818         u64 objectid;
 819         struct btrfs_trans_handle *trans;
 820
 821         trans = btrfs_start_transaction(root, 1);
 822         if (!trans)
 823                 return -ENOMEM;
 824         err = ext2fs_open_inode_scan(ext2_fs, 0, &ext2_scan);
 825         if (err) {
 826                 fprintf(stderr, "ext2fs_open_inode_scan: %s\n", error_message(err));
 827                 return -1;
 828         }
 829         while (!(err = ext2fs_get_next_inode(ext2_scan, &ext2_ino,
 830                                              &ext2_inode))) {
 831                 /* no more inodes */
 832                 if (ext2_ino == 0)
 833                         break;
 834                 /* skip special inode in ext2fs */
 835                 if (ext2_ino < EXT2_GOOD_OLD_FIRST_INO &&
 836                     ext2_ino != EXT2_ROOT_INO)
 837                         continue;
 838                 objectid = ext2_ino + INO_OFFSET;
 839                 ret = ext2_copy_single_inode(trans, root,
 840                                         objectid, ext2_fs, ext2_ino,
 841                                         &ext2_inode, datacsum, packing,
 842                                         noxattr);
 843                 p->cur_copy_inodes++;
 844                 if (ret)
 845                         return ret;
 846                 if (trans->blocks_used >= 4096) {
 847                         ret = btrfs_commit_transaction(trans, root);
 848                         BUG_ON(ret);
 849                         trans = btrfs_start_transaction(root, 1);
 850                         BUG_ON(!trans);
 851                 }
 852         }
 853         if (err) {
 854                 fprintf(stderr, "ext2fs_get_next_inode: %s\n", error_message(err));
 855                 return -1;
 856         }
 857         ret = btrfs_commit_transaction(trans, root);
 858         BUG_ON(ret);
 859         ext2fs_close_inode_scan(ext2_scan);
 860
 861         return ret;
 862 }
 863
 864 const struct btrfs_convert_operations ext2_convert_ops = {
 865         .name                   = "ext2",
 866         .open_fs                = ext2_open_fs,
 867         .read_used_space        = ext2_read_used_space,
 868         .copy_inodes            = ext2_copy_inodes,
 869         .close_fs               = ext2_close_fs,
 870         .check_state            = ext2_check_state,
 871 };
 872
 873 #endif  /* BTRFSCONVERT_EXT2 */