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