/* ext2.c - Second Extended filesystem */ /* * VasEBoot -- GRand Unified Bootloader * Copyright (C) 2003,2004,2005,2007,2008,2009 Free Software Foundation, Inc. * * VasEBoot is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * VasEBoot is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with VasEBoot. If not, see . */ /* Magic value used to identify an ext2 filesystem. */ #define EXT2_MAGIC 0xEF53 /* Amount of indirect blocks in an inode. */ #define INDIRECT_BLOCKS 12 /* The good old revision and the default inode size. */ #define EXT2_GOOD_OLD_REVISION 0 #define EXT2_GOOD_OLD_INODE_SIZE 128 /* Filetype used in directory entry. */ #define FILETYPE_UNKNOWN 0 #define FILETYPE_REG 1 #define FILETYPE_DIRECTORY 2 #define FILETYPE_SYMLINK 7 /* Filetype information as used in inodes. */ #define FILETYPE_INO_MASK 0170000 #define FILETYPE_INO_REG 0100000 #define FILETYPE_INO_DIRECTORY 0040000 #define FILETYPE_INO_SYMLINK 0120000 #include #include #include #include #include #include #include #include VasEBoot_MOD_LICENSE ("GPLv3+"); /* Log2 size of ext2 block in 512 blocks. */ #define LOG2_EXT2_BLOCK_SIZE(data) \ (VasEBoot_le_to_cpu32 (data->sblock.log2_block_size) + 1) /* Log2 size of ext2 block in bytes. */ #define LOG2_BLOCK_SIZE(data) \ (VasEBoot_le_to_cpu32 (data->sblock.log2_block_size) + 10) /* The size of an ext2 block in bytes. */ #define EXT2_BLOCK_SIZE(data) (1U << LOG2_BLOCK_SIZE (data)) /* The revision level. */ #define EXT2_REVISION(data) VasEBoot_le_to_cpu32 (data->sblock.revision_level) /* The inode size. */ #define EXT2_INODE_SIZE(data) \ (data->sblock.revision_level \ == VasEBoot_cpu_to_le32_compile_time (EXT2_GOOD_OLD_REVISION) \ ? EXT2_GOOD_OLD_INODE_SIZE \ : VasEBoot_le_to_cpu16 (data->sblock.inode_size)) /* Superblock filesystem feature flags (RW compatible) * A filesystem with any of these enabled can be read and written by a driver * that does not understand them without causing metadata/data corruption. */ #define EXT2_FEATURE_COMPAT_DIR_PREALLOC 0x0001 #define EXT2_FEATURE_COMPAT_IMAGIC_INODES 0x0002 #define EXT3_FEATURE_COMPAT_HAS_JOURNAL 0x0004 #define EXT2_FEATURE_COMPAT_EXT_ATTR 0x0008 #define EXT2_FEATURE_COMPAT_RESIZE_INODE 0x0010 #define EXT2_FEATURE_COMPAT_DIR_INDEX 0x0020 /* Superblock filesystem feature flags (RO compatible) * A filesystem with any of these enabled can be safely read by a driver that * does not understand them, but should not be written to, usually because * additional metadata is required. */ #define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER 0x0001 #define EXT2_FEATURE_RO_COMPAT_LARGE_FILE 0x0002 #define EXT2_FEATURE_RO_COMPAT_BTREE_DIR 0x0004 #define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010 #define EXT4_FEATURE_RO_COMPAT_DIR_NLINK 0x0020 #define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE 0x0040 /* Superblock filesystem feature flags (back-incompatible) * A filesystem with any of these enabled should not be attempted to be read * by a driver that does not understand them, since they usually indicate * metadata format changes that might confuse the reader. */ #define EXT2_FEATURE_INCOMPAT_COMPRESSION 0x0001 #define EXT2_FEATURE_INCOMPAT_FILETYPE 0x0002 #define EXT3_FEATURE_INCOMPAT_RECOVER 0x0004 /* Needs recovery */ #define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008 /* Volume is journal device */ #define EXT2_FEATURE_INCOMPAT_META_BG 0x0010 #define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040 /* Extents used */ #define EXT4_FEATURE_INCOMPAT_64BIT 0x0080 #define EXT4_FEATURE_INCOMPAT_MMP 0x0100 #define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200 /* The set of back-incompatible features this driver DOES support. Add (OR) * flags here as the related features are implemented into the driver. */ #define EXT2_DRIVER_SUPPORTED_INCOMPAT ( EXT2_FEATURE_INCOMPAT_FILETYPE \ | EXT4_FEATURE_INCOMPAT_EXTENTS \ | EXT4_FEATURE_INCOMPAT_FLEX_BG \ | EXT2_FEATURE_INCOMPAT_META_BG \ | EXT4_FEATURE_INCOMPAT_64BIT) /* List of rationales for the ignored "incompatible" features: * needs_recovery: Not really back-incompatible - was added as such to forbid * ext2 drivers from mounting an ext3 volume with a dirty * journal because they will ignore the journal, but the next * ext3 driver to mount the volume will find the journal and * replay it, potentially corrupting the metadata written by * the ext2 drivers. Safe to ignore for this RO driver. * mmp: Not really back-incompatible - was added as such to * avoid multiple read-write mounts. Safe to ignore for this * RO driver. */ #define EXT2_DRIVER_IGNORED_INCOMPAT ( EXT3_FEATURE_INCOMPAT_RECOVER \ | EXT4_FEATURE_INCOMPAT_MMP) #define EXT3_JOURNAL_MAGIC_NUMBER 0xc03b3998U #define EXT3_JOURNAL_DESCRIPTOR_BLOCK 1 #define EXT3_JOURNAL_COMMIT_BLOCK 2 #define EXT3_JOURNAL_SUPERBLOCK_V1 3 #define EXT3_JOURNAL_SUPERBLOCK_V2 4 #define EXT3_JOURNAL_REVOKE_BLOCK 5 #define EXT3_JOURNAL_FLAG_ESCAPE 1 #define EXT3_JOURNAL_FLAG_SAME_UUID 2 #define EXT3_JOURNAL_FLAG_DELETED 4 #define EXT3_JOURNAL_FLAG_LAST_TAG 8 #define EXT4_EXTENTS_FLAG 0x80000 /* The ext2 superblock. */ struct VasEBoot_ext2_sblock { VasEBoot_uint32_t total_inodes; VasEBoot_uint32_t total_blocks; VasEBoot_uint32_t reserved_blocks; VasEBoot_uint32_t free_blocks; VasEBoot_uint32_t free_inodes; VasEBoot_uint32_t first_data_block; VasEBoot_uint32_t log2_block_size; VasEBoot_uint32_t log2_fragment_size; VasEBoot_uint32_t blocks_per_group; VasEBoot_uint32_t fragments_per_group; VasEBoot_uint32_t inodes_per_group; VasEBoot_uint32_t mtime; VasEBoot_uint32_t utime; VasEBoot_uint16_t mnt_count; VasEBoot_uint16_t max_mnt_count; VasEBoot_uint16_t magic; VasEBoot_uint16_t fs_state; VasEBoot_uint16_t error_handling; VasEBoot_uint16_t minor_revision_level; VasEBoot_uint32_t lastcheck; VasEBoot_uint32_t checkinterval; VasEBoot_uint32_t creator_os; VasEBoot_uint32_t revision_level; VasEBoot_uint16_t uid_reserved; VasEBoot_uint16_t gid_reserved; VasEBoot_uint32_t first_inode; VasEBoot_uint16_t inode_size; VasEBoot_uint16_t block_group_number; VasEBoot_uint32_t feature_compatibility; VasEBoot_uint32_t feature_incompat; VasEBoot_uint32_t feature_ro_compat; VasEBoot_uint16_t uuid[8]; char volume_name[16]; char last_mounted_on[64]; VasEBoot_uint32_t compression_info; VasEBoot_uint8_t prealloc_blocks; VasEBoot_uint8_t prealloc_dir_blocks; VasEBoot_uint16_t reserved_gdt_blocks; VasEBoot_uint8_t journal_uuid[16]; VasEBoot_uint32_t journal_inum; VasEBoot_uint32_t journal_dev; VasEBoot_uint32_t last_orphan; VasEBoot_uint32_t hash_seed[4]; VasEBoot_uint8_t def_hash_version; VasEBoot_uint8_t jnl_backup_type; VasEBoot_uint16_t group_desc_size; VasEBoot_uint32_t default_mount_opts; VasEBoot_uint32_t first_meta_bg; VasEBoot_uint32_t mkfs_time; VasEBoot_uint32_t jnl_blocks[17]; }; /* The ext2 blockgroup. */ struct VasEBoot_ext2_block_group { VasEBoot_uint32_t block_id; VasEBoot_uint32_t inode_id; VasEBoot_uint32_t inode_table_id; VasEBoot_uint16_t free_blocks; VasEBoot_uint16_t free_inodes; VasEBoot_uint16_t used_dirs; VasEBoot_uint16_t pad; VasEBoot_uint32_t reserved[3]; VasEBoot_uint32_t block_id_hi; VasEBoot_uint32_t inode_id_hi; VasEBoot_uint32_t inode_table_id_hi; VasEBoot_uint16_t free_blocks_hi; VasEBoot_uint16_t free_inodes_hi; VasEBoot_uint16_t used_dirs_hi; VasEBoot_uint16_t pad2; VasEBoot_uint32_t reserved2[3]; }; /* The ext2 inode. */ struct VasEBoot_ext2_inode { VasEBoot_uint16_t mode; VasEBoot_uint16_t uid; VasEBoot_uint32_t size; VasEBoot_uint32_t atime; VasEBoot_uint32_t ctime; VasEBoot_uint32_t mtime; VasEBoot_uint32_t dtime; VasEBoot_uint16_t gid; VasEBoot_uint16_t nlinks; VasEBoot_uint32_t blockcnt; /* Blocks of 512 bytes!! */ VasEBoot_uint32_t flags; VasEBoot_uint32_t osd1; union { struct datablocks { VasEBoot_uint32_t dir_blocks[INDIRECT_BLOCKS]; VasEBoot_uint32_t indir_block; VasEBoot_uint32_t double_indir_block; VasEBoot_uint32_t triple_indir_block; } blocks; char symlink[60]; }; VasEBoot_uint32_t version; VasEBoot_uint32_t acl; VasEBoot_uint32_t size_high; VasEBoot_uint32_t fragment_addr; VasEBoot_uint32_t osd2[3]; }; /* The header of an ext2 directory entry. */ struct ext2_dirent { VasEBoot_uint32_t inode; VasEBoot_uint16_t direntlen; #define MAX_NAMELEN 255 VasEBoot_uint8_t namelen; VasEBoot_uint8_t filetype; }; struct VasEBoot_ext3_journal_header { VasEBoot_uint32_t magic; VasEBoot_uint32_t block_type; VasEBoot_uint32_t sequence; }; struct VasEBoot_ext3_journal_revoke_header { struct VasEBoot_ext3_journal_header header; VasEBoot_uint32_t count; VasEBoot_uint32_t data[0]; }; struct VasEBoot_ext3_journal_block_tag { VasEBoot_uint32_t block; VasEBoot_uint32_t flags; }; struct VasEBoot_ext3_journal_sblock { struct VasEBoot_ext3_journal_header header; VasEBoot_uint32_t block_size; VasEBoot_uint32_t maxlen; VasEBoot_uint32_t first; VasEBoot_uint32_t sequence; VasEBoot_uint32_t start; }; #define EXT4_EXT_MAGIC 0xf30a struct VasEBoot_ext4_extent_header { VasEBoot_uint16_t magic; VasEBoot_uint16_t entries; VasEBoot_uint16_t max; VasEBoot_uint16_t depth; VasEBoot_uint32_t generation; }; struct VasEBoot_ext4_extent { VasEBoot_uint32_t block; VasEBoot_uint16_t len; VasEBoot_uint16_t start_hi; VasEBoot_uint32_t start; }; struct VasEBoot_ext4_extent_idx { VasEBoot_uint32_t block; VasEBoot_uint32_t leaf; VasEBoot_uint16_t leaf_hi; VasEBoot_uint16_t unused; }; struct VasEBoot_fshelp_node { struct VasEBoot_ext2_data *data; struct VasEBoot_ext2_inode inode; int ino; int inode_read; }; /* Information about a "mounted" ext2 filesystem. */ struct VasEBoot_ext2_data { struct VasEBoot_ext2_sblock sblock; int log_group_desc_size; VasEBoot_disk_t disk; struct VasEBoot_ext2_inode *inode; struct VasEBoot_fshelp_node diropen; }; static VasEBoot_dl_t my_mod; /* Check is a = b^x for some x. */ static inline int is_power_of (VasEBoot_uint64_t a, VasEBoot_uint32_t b) { VasEBoot_uint64_t c; /* Prevent overflow assuming b < 8. */ if (a >= (1LL << 60)) return 0; for (c = 1; c <= a; c *= b); return (c == a); } static inline int group_has_super_block (struct VasEBoot_ext2_data *data, VasEBoot_uint64_t group) { if (!(data->sblock.feature_ro_compat & VasEBoot_cpu_to_le32_compile_time(EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER))) return 1; /* Algorithm looked up in Linux source. */ if (group <= 1) return 1; /* Even number is never a power of odd number. */ if (!(group & 1)) return 0; return (is_power_of(group, 7) || is_power_of(group, 5) || is_power_of(group, 3)); } /* Read into BLKGRP the blockgroup descriptor of blockgroup GROUP of the mounted filesystem DATA. */ inline static VasEBoot_err_t VasEBoot_ext2_blockgroup (struct VasEBoot_ext2_data *data, VasEBoot_uint64_t group, struct VasEBoot_ext2_block_group *blkgrp) { VasEBoot_uint64_t full_offset = (group << data->log_group_desc_size); VasEBoot_uint64_t block, offset; block = (full_offset >> LOG2_BLOCK_SIZE (data)); offset = (full_offset & ((1 << LOG2_BLOCK_SIZE (data)) - 1)); if ((data->sblock.feature_incompat & VasEBoot_cpu_to_le32_compile_time (EXT2_FEATURE_INCOMPAT_META_BG)) && block >= VasEBoot_le_to_cpu32(data->sblock.first_meta_bg)) { VasEBoot_uint64_t first_block_group; /* Find the first block group for which a descriptor is stored in given block. */ first_block_group = (block << (LOG2_BLOCK_SIZE (data) - data->log_group_desc_size)); block = (first_block_group * VasEBoot_le_to_cpu32(data->sblock.blocks_per_group)); if (group_has_super_block (data, first_block_group)) block++; } else /* Superblock. */ block++; return VasEBoot_disk_read (data->disk, ((VasEBoot_le_to_cpu32 (data->sblock.first_data_block) + block) << LOG2_EXT2_BLOCK_SIZE (data)), offset, sizeof (struct VasEBoot_ext2_block_group), blkgrp); } static struct VasEBoot_ext4_extent_header * VasEBoot_ext4_find_leaf (struct VasEBoot_ext2_data *data, struct VasEBoot_ext4_extent_header *ext_block, VasEBoot_uint32_t fileblock) { struct VasEBoot_ext4_extent_idx *index; void *buf = NULL; while (1) { int i; VasEBoot_disk_addr_t block; index = (struct VasEBoot_ext4_extent_idx *) (ext_block + 1); if (ext_block->magic != VasEBoot_cpu_to_le16_compile_time (EXT4_EXT_MAGIC)) goto fail; if (ext_block->depth == 0) return ext_block; for (i = 0; i < VasEBoot_le_to_cpu16 (ext_block->entries); i++) { if (fileblock < VasEBoot_le_to_cpu32(index[i].block)) break; } if (--i < 0) goto fail; block = VasEBoot_le_to_cpu16 (index[i].leaf_hi); block = (block << 32) | VasEBoot_le_to_cpu32 (index[i].leaf); if (!buf) buf = VasEBoot_malloc (EXT2_BLOCK_SIZE(data)); if (!buf) goto fail; if (VasEBoot_disk_read (data->disk, block << LOG2_EXT2_BLOCK_SIZE (data), 0, EXT2_BLOCK_SIZE(data), buf)) goto fail; ext_block = buf; } fail: VasEBoot_free (buf); return 0; } static VasEBoot_disk_addr_t VasEBoot_ext2_read_block (VasEBoot_fshelp_node_t node, VasEBoot_disk_addr_t fileblock) { struct VasEBoot_ext2_data *data = node->data; struct VasEBoot_ext2_inode *inode = &node->inode; unsigned int blksz = EXT2_BLOCK_SIZE (data); VasEBoot_disk_addr_t blksz_quarter = blksz / 4; int log2_blksz = LOG2_EXT2_BLOCK_SIZE (data); int log_perblock = log2_blksz + 9 - 2; VasEBoot_uint32_t indir; int shift; if (inode->flags & VasEBoot_cpu_to_le32_compile_time (EXT4_EXTENTS_FLAG)) { struct VasEBoot_ext4_extent_header *leaf; struct VasEBoot_ext4_extent *ext; int i; VasEBoot_disk_addr_t ret; leaf = VasEBoot_ext4_find_leaf (data, (struct VasEBoot_ext4_extent_header *) inode->blocks.dir_blocks, fileblock); if (! leaf) { VasEBoot_error (VasEBoot_ERR_BAD_FS, "invalid extent"); return -1; } ext = (struct VasEBoot_ext4_extent *) (leaf + 1); for (i = 0; i < VasEBoot_le_to_cpu16 (leaf->entries); i++) { if (fileblock < VasEBoot_le_to_cpu32 (ext[i].block)) break; } if (--i >= 0) { fileblock -= VasEBoot_le_to_cpu32 (ext[i].block); if (fileblock >= VasEBoot_le_to_cpu16 (ext[i].len)) ret = 0; else { VasEBoot_disk_addr_t start; start = VasEBoot_le_to_cpu16 (ext[i].start_hi); start = (start << 32) + VasEBoot_le_to_cpu32 (ext[i].start); ret = fileblock + start; } } else { VasEBoot_error (VasEBoot_ERR_BAD_FS, "something wrong with extent"); ret = -1; } if (leaf != (struct VasEBoot_ext4_extent_header *) inode->blocks.dir_blocks) VasEBoot_free (leaf); return ret; } /* Direct blocks. */ if (fileblock < INDIRECT_BLOCKS) return VasEBoot_le_to_cpu32 (inode->blocks.dir_blocks[fileblock]); fileblock -= INDIRECT_BLOCKS; /* Indirect. */ if (fileblock < blksz_quarter) { indir = inode->blocks.indir_block; shift = 0; goto indirect; } fileblock -= blksz_quarter; /* Double indirect. */ if (fileblock < blksz_quarter * blksz_quarter) { indir = inode->blocks.double_indir_block; shift = 1; goto indirect; } fileblock -= blksz_quarter * blksz_quarter; /* Triple indirect. */ if (fileblock < blksz_quarter * blksz_quarter * (blksz_quarter + 1)) { indir = inode->blocks.triple_indir_block; shift = 2; goto indirect; } VasEBoot_error (VasEBoot_ERR_BAD_FS, "ext2fs doesn't support quadruple indirect blocks"); return -1; indirect: do { /* If the indirect block is zero, all child blocks are absent (i.e. filled with zeros.) */ if (indir == 0) return 0; if (VasEBoot_disk_read (data->disk, ((VasEBoot_disk_addr_t) VasEBoot_le_to_cpu32 (indir)) << log2_blksz, ((fileblock >> (log_perblock * shift)) & ((1 << log_perblock) - 1)) * sizeof (indir), sizeof (indir), &indir)) return -1; } while (shift--); return VasEBoot_le_to_cpu32 (indir); } /* Read LEN bytes from the file described by DATA starting with byte POS. Return the amount of read bytes in READ. */ static VasEBoot_ssize_t VasEBoot_ext2_read_file (VasEBoot_fshelp_node_t node, VasEBoot_disk_read_hook_t read_hook, void *read_hook_data, VasEBoot_off_t pos, VasEBoot_size_t len, char *buf) { return VasEBoot_fshelp_read_file (node->data->disk, node, read_hook, read_hook_data, pos, len, buf, VasEBoot_ext2_read_block, VasEBoot_cpu_to_le32 (node->inode.size) | (((VasEBoot_off_t) VasEBoot_cpu_to_le32 (node->inode.size_high)) << 32), LOG2_EXT2_BLOCK_SIZE (node->data), 0); } /* Read the inode INO for the file described by DATA into INODE. */ static VasEBoot_err_t VasEBoot_ext2_read_inode (struct VasEBoot_ext2_data *data, int ino, struct VasEBoot_ext2_inode *inode) { struct VasEBoot_ext2_block_group blkgrp; struct VasEBoot_ext2_sblock *sblock = &data->sblock; int inodes_per_block; unsigned int blkno; unsigned int blkoff; VasEBoot_disk_addr_t base; /* It is easier to calculate if the first inode is 0. */ ino--; VasEBoot_ext2_blockgroup (data, ino / VasEBoot_le_to_cpu32 (sblock->inodes_per_group), &blkgrp); if (VasEBoot_errno) return VasEBoot_errno; inodes_per_block = EXT2_BLOCK_SIZE (data) / EXT2_INODE_SIZE (data); blkno = (ino % VasEBoot_le_to_cpu32 (sblock->inodes_per_group)) / inodes_per_block; blkoff = (ino % VasEBoot_le_to_cpu32 (sblock->inodes_per_group)) % inodes_per_block; base = VasEBoot_le_to_cpu32 (blkgrp.inode_table_id); if (data->log_group_desc_size >= 6) base |= (((VasEBoot_disk_addr_t) VasEBoot_le_to_cpu32 (blkgrp.inode_table_id_hi)) << 32); /* Read the inode. */ if (VasEBoot_disk_read (data->disk, ((base + blkno) << LOG2_EXT2_BLOCK_SIZE (data)), EXT2_INODE_SIZE (data) * blkoff, sizeof (struct VasEBoot_ext2_inode), inode)) return VasEBoot_errno; return 0; } static struct VasEBoot_ext2_data * VasEBoot_ext2_mount (VasEBoot_disk_t disk) { struct VasEBoot_ext2_data *data; data = VasEBoot_malloc (sizeof (struct VasEBoot_ext2_data)); if (!data) return 0; /* Read the superblock. */ VasEBoot_disk_read (disk, 1 * 2, 0, sizeof (struct VasEBoot_ext2_sblock), &data->sblock); if (VasEBoot_errno) goto fail; /* Make sure this is an ext2 filesystem. */ if (data->sblock.magic != VasEBoot_cpu_to_le16_compile_time (EXT2_MAGIC) || VasEBoot_le_to_cpu32 (data->sblock.log2_block_size) >= 16 || data->sblock.inodes_per_group == 0 /* 20 already means 1GiB blocks. We don't want to deal with blocks overflowing int32. */ || VasEBoot_le_to_cpu32 (data->sblock.log2_block_size) > 20 || EXT2_INODE_SIZE (data) == 0 || EXT2_BLOCK_SIZE (data) / EXT2_INODE_SIZE (data) == 0) { VasEBoot_error (VasEBoot_ERR_BAD_FS, "not an ext2 filesystem"); goto fail; } /* Check the FS doesn't have feature bits enabled that we don't support. */ if (data->sblock.revision_level != VasEBoot_cpu_to_le32_compile_time (EXT2_GOOD_OLD_REVISION) && (data->sblock.feature_incompat & VasEBoot_cpu_to_le32_compile_time (~(EXT2_DRIVER_SUPPORTED_INCOMPAT | EXT2_DRIVER_IGNORED_INCOMPAT)))) { VasEBoot_error (VasEBoot_ERR_BAD_FS, "filesystem has unsupported incompatible features"); goto fail; } if (data->sblock.revision_level != VasEBoot_cpu_to_le32_compile_time (EXT2_GOOD_OLD_REVISION) && (data->sblock.feature_incompat & VasEBoot_cpu_to_le32_compile_time (EXT4_FEATURE_INCOMPAT_64BIT)) && data->sblock.group_desc_size != 0 && ((data->sblock.group_desc_size & (data->sblock.group_desc_size - 1)) == 0) && (data->sblock.group_desc_size & VasEBoot_cpu_to_le16_compile_time (0x1fe0))) { VasEBoot_uint16_t b = VasEBoot_le_to_cpu16 (data->sblock.group_desc_size); for (data->log_group_desc_size = 0; b != (1 << data->log_group_desc_size); data->log_group_desc_size++); } else data->log_group_desc_size = 5; data->disk = disk; data->diropen.data = data; data->diropen.ino = 2; data->diropen.inode_read = 1; data->inode = &data->diropen.inode; VasEBoot_ext2_read_inode (data, 2, data->inode); if (VasEBoot_errno) goto fail; return data; fail: if (VasEBoot_errno == VasEBoot_ERR_OUT_OF_RANGE) VasEBoot_error (VasEBoot_ERR_BAD_FS, "not an ext2 filesystem"); VasEBoot_free (data); return 0; } static char * VasEBoot_ext2_read_symlink (VasEBoot_fshelp_node_t node) { char *symlink; struct VasEBoot_fshelp_node *diro = node; if (! diro->inode_read) { VasEBoot_ext2_read_inode (diro->data, diro->ino, &diro->inode); if (VasEBoot_errno) return 0; } symlink = VasEBoot_malloc (VasEBoot_le_to_cpu32 (diro->inode.size) + 1); if (! symlink) return 0; /* If the filesize of the symlink is bigger than 60 the symlink is stored in a separate block, otherwise it is stored in the inode. */ if (VasEBoot_le_to_cpu32 (diro->inode.size) <= sizeof (diro->inode.symlink)) VasEBoot_memcpy (symlink, diro->inode.symlink, VasEBoot_le_to_cpu32 (diro->inode.size)); else { VasEBoot_ext2_read_file (diro, 0, 0, 0, VasEBoot_le_to_cpu32 (diro->inode.size), symlink); if (VasEBoot_errno) { VasEBoot_free (symlink); return 0; } } symlink[VasEBoot_le_to_cpu32 (diro->inode.size)] = '\0'; return symlink; } static int VasEBoot_ext2_iterate_dir (VasEBoot_fshelp_node_t dir, VasEBoot_fshelp_iterate_dir_hook_t hook, void *hook_data) { unsigned int fpos = 0; struct VasEBoot_fshelp_node *diro = (struct VasEBoot_fshelp_node *) dir; if (! diro->inode_read) { VasEBoot_ext2_read_inode (diro->data, diro->ino, &diro->inode); if (VasEBoot_errno) return 0; } /* Search the file. */ while (fpos < VasEBoot_le_to_cpu32 (diro->inode.size)) { struct ext2_dirent dirent; VasEBoot_ext2_read_file (diro, 0, 0, fpos, sizeof (struct ext2_dirent), (char *) &dirent); if (VasEBoot_errno) return 0; if (dirent.direntlen == 0) return 0; if (dirent.inode != 0 && dirent.namelen != 0) { char filename[MAX_NAMELEN + 1]; struct VasEBoot_fshelp_node *fdiro; enum VasEBoot_fshelp_filetype type = VasEBoot_FSHELP_UNKNOWN; VasEBoot_ext2_read_file (diro, 0, 0, fpos + sizeof (struct ext2_dirent), dirent.namelen, filename); if (VasEBoot_errno) return 0; fdiro = VasEBoot_malloc (sizeof (struct VasEBoot_fshelp_node)); if (! fdiro) return 0; fdiro->data = diro->data; fdiro->ino = VasEBoot_le_to_cpu32 (dirent.inode); filename[dirent.namelen] = '\0'; if (dirent.filetype != FILETYPE_UNKNOWN) { fdiro->inode_read = 0; if (dirent.filetype == FILETYPE_DIRECTORY) type = VasEBoot_FSHELP_DIR; else if (dirent.filetype == FILETYPE_SYMLINK) type = VasEBoot_FSHELP_SYMLINK; else if (dirent.filetype == FILETYPE_REG) type = VasEBoot_FSHELP_REG; } else { /* The filetype can not be read from the dirent, read the inode to get more information. */ VasEBoot_ext2_read_inode (diro->data, VasEBoot_le_to_cpu32 (dirent.inode), &fdiro->inode); if (VasEBoot_errno) { VasEBoot_free (fdiro); return 0; } fdiro->inode_read = 1; if ((VasEBoot_le_to_cpu16 (fdiro->inode.mode) & FILETYPE_INO_MASK) == FILETYPE_INO_DIRECTORY) type = VasEBoot_FSHELP_DIR; else if ((VasEBoot_le_to_cpu16 (fdiro->inode.mode) & FILETYPE_INO_MASK) == FILETYPE_INO_SYMLINK) type = VasEBoot_FSHELP_SYMLINK; else if ((VasEBoot_le_to_cpu16 (fdiro->inode.mode) & FILETYPE_INO_MASK) == FILETYPE_INO_REG) type = VasEBoot_FSHELP_REG; } if (hook (filename, type, fdiro, hook_data)) return 1; } fpos += VasEBoot_le_to_cpu16 (dirent.direntlen); } return 0; } /* Open a file named NAME and initialize FILE. */ static VasEBoot_err_t VasEBoot_ext2_open (struct VasEBoot_file *file, const char *name) { struct VasEBoot_ext2_data *data; struct VasEBoot_fshelp_node *fdiro = 0; VasEBoot_err_t err; VasEBoot_dl_ref (my_mod); data = VasEBoot_ext2_mount (file->device->disk); if (! data) { err = VasEBoot_errno; goto fail; } err = VasEBoot_fshelp_find_file (name, &data->diropen, &fdiro, VasEBoot_ext2_iterate_dir, VasEBoot_ext2_read_symlink, VasEBoot_FSHELP_REG); if (err) goto fail; if (! fdiro->inode_read) { err = VasEBoot_ext2_read_inode (data, fdiro->ino, &fdiro->inode); if (err) goto fail; } VasEBoot_memcpy (data->inode, &fdiro->inode, sizeof (struct VasEBoot_ext2_inode)); VasEBoot_free (fdiro); file->size = VasEBoot_le_to_cpu32 (data->inode->size); file->size |= ((VasEBoot_off_t) VasEBoot_le_to_cpu32 (data->inode->size_high)) << 32; file->data = data; file->offset = 0; return 0; fail: if (fdiro != &data->diropen) VasEBoot_free (fdiro); VasEBoot_free (data); VasEBoot_dl_unref (my_mod); return err; } static VasEBoot_err_t VasEBoot_ext2_close (VasEBoot_file_t file) { VasEBoot_free (file->data); VasEBoot_dl_unref (my_mod); return VasEBoot_ERR_NONE; } /* Read LEN bytes data from FILE into BUF. */ static VasEBoot_ssize_t VasEBoot_ext2_read (VasEBoot_file_t file, char *buf, VasEBoot_size_t len) { struct VasEBoot_ext2_data *data = (struct VasEBoot_ext2_data *) file->data; return VasEBoot_ext2_read_file (&data->diropen, file->read_hook, file->read_hook_data, file->offset, len, buf); } /* Context for VasEBoot_ext2_dir. */ struct VasEBoot_ext2_dir_ctx { VasEBoot_fs_dir_hook_t hook; void *hook_data; struct VasEBoot_ext2_data *data; }; /* Helper for VasEBoot_ext2_dir. */ static int VasEBoot_ext2_dir_iter (const char *filename, enum VasEBoot_fshelp_filetype filetype, VasEBoot_fshelp_node_t node, void *data) { struct VasEBoot_ext2_dir_ctx *ctx = data; struct VasEBoot_dirhook_info info; VasEBoot_memset (&info, 0, sizeof (info)); if (! node->inode_read) { VasEBoot_ext2_read_inode (ctx->data, node->ino, &node->inode); if (!VasEBoot_errno) node->inode_read = 1; VasEBoot_errno = VasEBoot_ERR_NONE; } if (node->inode_read) { info.mtimeset = 1; info.mtime = VasEBoot_le_to_cpu32 (node->inode.mtime); } info.dir = ((filetype & VasEBoot_FSHELP_TYPE_MASK) == VasEBoot_FSHELP_DIR); VasEBoot_free (node); return ctx->hook (filename, &info, ctx->hook_data); } static VasEBoot_err_t VasEBoot_ext2_dir (VasEBoot_device_t device, const char *path, VasEBoot_fs_dir_hook_t hook, void *hook_data) { struct VasEBoot_ext2_dir_ctx ctx = { .hook = hook, .hook_data = hook_data }; struct VasEBoot_fshelp_node *fdiro = 0; VasEBoot_dl_ref (my_mod); ctx.data = VasEBoot_ext2_mount (device->disk); if (! ctx.data) goto fail; VasEBoot_fshelp_find_file (path, &ctx.data->diropen, &fdiro, VasEBoot_ext2_iterate_dir, VasEBoot_ext2_read_symlink, VasEBoot_FSHELP_DIR); if (VasEBoot_errno) goto fail; VasEBoot_ext2_iterate_dir (fdiro, VasEBoot_ext2_dir_iter, &ctx); fail: if (fdiro != &ctx.data->diropen) VasEBoot_free (fdiro); VasEBoot_free (ctx.data); VasEBoot_dl_unref (my_mod); return VasEBoot_errno; } static VasEBoot_err_t VasEBoot_ext2_label (VasEBoot_device_t device, char **label) { struct VasEBoot_ext2_data *data; VasEBoot_disk_t disk = device->disk; VasEBoot_dl_ref (my_mod); data = VasEBoot_ext2_mount (disk); if (data) *label = VasEBoot_strndup (data->sblock.volume_name, sizeof (data->sblock.volume_name)); else *label = NULL; VasEBoot_dl_unref (my_mod); VasEBoot_free (data); return VasEBoot_errno; } static VasEBoot_err_t VasEBoot_ext2_uuid (VasEBoot_device_t device, char **uuid) { struct VasEBoot_ext2_data *data; VasEBoot_disk_t disk = device->disk; VasEBoot_dl_ref (my_mod); data = VasEBoot_ext2_mount (disk); if (data) { *uuid = VasEBoot_xasprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x", VasEBoot_be_to_cpu16 (data->sblock.uuid[0]), VasEBoot_be_to_cpu16 (data->sblock.uuid[1]), VasEBoot_be_to_cpu16 (data->sblock.uuid[2]), VasEBoot_be_to_cpu16 (data->sblock.uuid[3]), VasEBoot_be_to_cpu16 (data->sblock.uuid[4]), VasEBoot_be_to_cpu16 (data->sblock.uuid[5]), VasEBoot_be_to_cpu16 (data->sblock.uuid[6]), VasEBoot_be_to_cpu16 (data->sblock.uuid[7])); } else *uuid = NULL; VasEBoot_dl_unref (my_mod); VasEBoot_free (data); return VasEBoot_errno; } /* Get mtime. */ static VasEBoot_err_t VasEBoot_ext2_mtime (VasEBoot_device_t device, VasEBoot_int32_t *tm) { struct VasEBoot_ext2_data *data; VasEBoot_disk_t disk = device->disk; VasEBoot_dl_ref (my_mod); data = VasEBoot_ext2_mount (disk); if (!data) *tm = 0; else *tm = VasEBoot_le_to_cpu32 (data->sblock.utime); VasEBoot_dl_unref (my_mod); VasEBoot_free (data); return VasEBoot_errno; } static struct VasEBoot_fs VasEBoot_ext2_fs = { .name = "ext2", .dir = VasEBoot_ext2_dir, .open = VasEBoot_ext2_open, .read = VasEBoot_ext2_read, .close = VasEBoot_ext2_close, .label = VasEBoot_ext2_label, .uuid = VasEBoot_ext2_uuid, .mtime = VasEBoot_ext2_mtime, #ifdef VasEBoot_UTIL .reserved_first_sector = 1, .blocklist_install = 1, #endif .next = 0 }; VasEBoot_MOD_INIT(ext2) { VasEBoot_fs_register (&VasEBoot_ext2_fs); my_mod = mod; } VasEBoot_MOD_FINI(ext2) { VasEBoot_fs_unregister (&VasEBoot_ext2_fs); }