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