Author: stepan Date: Sat Feb 12 03:01:44 2011 New Revision: 140 URL: http://tracker.coreboot.org/trac/filo/changeset/140
Log: Allow FILO to boot off EXT4 partitions. Using adapted http://grub4ext4.googlecode.com/svn/trunk/ext4-support Signed-off-by: Stefan Reinauer <[email protected]> Acked-by: Stefan Reinauer <[email protected]> Modified: trunk/filo/fs/fsys_ext2fs.c Modified: trunk/filo/fs/fsys_ext2fs.c ============================================================================== --- trunk/filo/fs/fsys_ext2fs.c Fri Dec 10 05:09:57 2010 (r139) +++ trunk/filo/fs/fsys_ext2fs.c Sat Feb 12 03:01:44 2011 (r140) @@ -38,6 +38,7 @@ typedef unsigned short __u16; typedef __signed__ int __s32; typedef unsigned int __u32; +typedef unsigned long long __u64; /* * Constants relative to the data blocks, from ext2_fs.h @@ -48,7 +49,7 @@ #define EXT2_TIND_BLOCK (EXT2_DIND_BLOCK + 1) #define EXT2_N_BLOCKS (EXT2_TIND_BLOCK + 1) -/* include/linux/ext2_fs.h */ +/* lib/ext2fs/ext2_fs.h from e2fsprogs */ struct ext2_super_block { __u32 s_inodes_count; /* Inodes count */ @@ -58,9 +59,9 @@ __u32 s_free_inodes_count; /* Free inodes count */ __u32 s_first_data_block; /* First Data Block */ __u32 s_log_block_size; /* Block size */ - __s32 s_log_frag_size; /* Fragment size */ + __s32 s_obso_log_frag_size; /* Obsoleted Fragment size */ __u32 s_blocks_per_group; /* # Blocks per group */ - __u32 s_frags_per_group; /* # Fragments per group */ + __u32 s_obso_frags_per_group; /* Obsoleted Fragments per group */ __u32 s_inodes_per_group; /* # Inodes per group */ __u32 s_mtime; /* Mount time */ __u32 s_wtime; /* Write time */ @@ -69,7 +70,7 @@ __u16 s_magic; /* Magic signature */ __u16 s_state; /* File system state */ __u16 s_errors; /* Behaviour when detecting errors */ - __u16 s_pad; + __u16 s_minor_rev_level; /* minor revision level */ __u32 s_lastcheck; /* time of last check */ __u32 s_checkinterval; /* max. time between checks */ __u32 s_creator_os; /* OS */ @@ -105,7 +106,7 @@ */ __u8 s_prealloc_blocks; /* Nr of blocks to try to preallocate*/ __u8 s_prealloc_dir_blocks; /* Nr to preallocate for dirs */ - __u16 s_padding1; + __u16 s_reserved_gdt_blocks; /* Per group desc for online growth */ /* * Journaling support valid if EXT3_FEATURE_COMPAT_HAS_JOURNAL set. */ @@ -115,14 +116,30 @@ __u32 s_last_orphan; /* start of list of inodes to delete */ __u32 s_hash_seed[4]; /* HTREE hash seed */ __u8 s_def_hash_version; /* Default hash version to use */ - __u8 s_reserved_char_pad; - __u16 s_reserved_word_pad; + __u8 s_jnl_backup_type; /* Default type of journal backup */ + __u16 s_desc_size; /* size of group descriptor */ __u32 s_default_mount_opts; __u32 s_first_meta_bg; /* First metablock block group */ - __u32 s_reserved[190]; /* Padding to the end of the block */ + __u32 s_mkfs_time; /* When the filesystem was created */ + __u32 s_jnl_blocks[17]; /* Backup of journal inode */ + /* 64bit desc support valid if EXT4_FEATURE_INCOMPAT_64BIT */ + __u32 s_blocks_count_hi; /* Blocks count */ + __u32 s_r_blocks_count_hi;/* Reserved blocks count */ + __u32 s_free_blocks_count_hi; /* Free blocks count */ + __u16 s_min_extra_isize; /* All inodes have at least # bytes */ + __u16 s_max_extra_isize; /* New inodes should reverve # bytes */ + __u32 s_flags; /* Miscellaneous flags */ + __u16 s_raid_stride; /* Raid stride */ + __u16 s_mmp_interval; /* # seconds to wait MMP checking */ + __u64 s_mmp_block; /* Block for multi-mount protection */ + __u32 s_raid_stripe_width; /* Blocks on all data disks (N*stride)*/ + __u8 s_log_groups_per_flex; /* FLEX_BG group size*/ + __u8 s_reserved_char_pad; + __u16 s_reserved_pad; + __u32 s_reserved[162]; /* Padding to the end of the block */ }; -struct ext2_group_desc +struct ext4_group_desc { __u32 bg_block_bitmap; /* Blocks bitmap block */ __u32 bg_inode_bitmap; /* Inodes bitmap block */ @@ -130,8 +147,18 @@ __u16 bg_free_blocks_count; /* Free blocks count */ __u16 bg_free_inodes_count; /* Free inodes count */ __u16 bg_used_dirs_count; /* Directories count */ - __u16 bg_pad; - __u32 bg_reserved[3]; + __u16 bg_flags; /* EXT4_BG_flags (INODE_UNINIT, etc) */ + __u32 bg_reserved[2]; /* Likely block/inode bitmap checksum */ + __u16 bg_itable_unused; /* Unused inodes count */ + __u16 bg_checksum; /* crc16(sb_uuid+group+desc) */ + __u32 bg_block_bitmap_hi; /* Blocks bitmap block MSB */ + __u32 bg_inode_bitmap_hi; /* Inodes bitmap block MSB */ + __u32 bg_inode_table_hi; /* Inodes table block MSB */ + __u16 bg_free_blocks_count_hi;/* Free blocks count MSB */ + __u16 bg_free_inodes_count_hi;/* Free inodes count MSB */ + __u16 bg_used_dirs_count_hi; /* Directories count MSB */ + __u16 bg_itable_unused_hi; /* Unused inodes count MSB */ + __u32 bg_reserved2[3]; }; struct ext2_inode @@ -169,22 +196,22 @@ __u32 i_block[EXT2_N_BLOCKS]; /* 40: Pointers to blocks */ __u32 i_version; /* File version (for NFS) */ __u32 i_file_acl; /* File ACL */ - __u32 i_dir_acl; /* Directory ACL */ - __u32 i_faddr; /* Fragment address */ + __u32 i_size_high; + __u32 i_obso_faddr; /* Obsoleted fragment address */ union { struct { - __u8 l_i_frag; /* Fragment number */ - __u8 l_i_fsize; /* Fragment size */ - __u16 i_pad1; - __u32 l_i_reserved2[2]; + __u16 l_i_blocks_high; /* were l_i_reserved1 */ + __u16 l_i_file_acl_high; + __u16 l_i_uid_high; /* these 2 fields */ + __u16 l_i_gid_high; /* were reserved2[0] */ + __u32 l_i_reserved2; } linux2; struct { - __u8 h_i_frag; /* Fragment number */ - __u8 h_i_fsize; /* Fragment size */ + __u16 h_i_reserved1; /* Obsoleted fragment number/size which are removed in ext4 */ __u16 h_i_mode_high; __u16 h_i_uid_high; __u16 h_i_gid_high; @@ -193,16 +220,36 @@ hurd2; struct { - __u8 m_i_frag; /* Fragment number */ - __u8 m_i_fsize; /* Fragment size */ - __u16 m_pad1; + __u16 h_i_reserved1; /* Obsoleted fragment number/size which are removed in ext4 */ + __u16 m_i_file_acl_high; __u32 m_i_reserved2[2]; } masix2; } osd2; /* OS dependent 2 */ + __u16 i_extra_isize; + __u16 i_pad1; + __u32 i_ctime_extra; /* extra Change time (nsec << 2 | epoch) */ + __u32 i_mtime_extra; /* extra Modification time(nsec << 2 | epoch) */ + __u32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */ + __u32 i_crtime; /* File Creation time */ + __u32 i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */ + __u32 i_version_hi; /* high 32 bits for 64-bit version */ }; +#define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040 /* extents support */ +#define EXT4_FEATURE_INCOMPAT_64BIT 0x0080 /* bergwolf:grub not supported*/ +#define EXT4_FEATURE_INCOMPAT_MMP 0x0100 +#define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200 + +#define EXT4_HAS_INCOMPAT_FEATURE(sb,mask) \ + ( sb->s_feature_incompat & mask ) + +#define EXT4_EXTENTS_FL 0x00080000 /* Inode uses extents */ +#define EXT4_HUGE_FILE_FL 0x00040000 /* Set to each huge file */ + +#define EXT4_MIN_DESC_SIZE 32 + /* linux/limits.h */ #define NAME_MAX 255 /* # chars in a file name */ @@ -220,6 +267,57 @@ char name[EXT2_NAME_LEN]; /* File name */ }; +/* linux/ext4_fs_extents.h */ +/* This is the extent on-disk structure. + * It's used at the bottom of the tree. + */ +struct ext4_extent + { + __u32 ee_block; /* first logical block extent covers */ + __u16 ee_len; /* number of blocks covered by extent */ + __u16 ee_start_hi; /* high 16 bits of physical block */ + __u32 ee_start_lo; /* low 32 bits of physical block */ + }; + +/* + * This is index on-disk structure. + * It's used at all the levels except the bottom. + */ +struct ext4_extent_idx + { + __u32 ei_block; /* index covers logical blocks from 'block' */ + __u32 ei_leaf_lo; /* pointer to the physical block of the next * + * level. leaf or next index could be there */ + __u16 ei_leaf_hi; /* high 16 bits of physical block */ + __u16 ei_unused; + }; + +/* + * Each block (leaves and indexes), even inode-stored has header. + */ +struct ext4_extent_header + { + __u16 eh_magic; /* probably will support different formats */ + __u16 eh_entries; /* number of valid entries */ + __u16 eh_max; /* capacity of store in entries */ + __u16 eh_depth; /* has tree real underlying blocks? */ + __u32 eh_generation; /* generation of the tree */ + }; + +#define EXT4_EXT_MAGIC (0xf30a) +#define EXT_FIRST_EXTENT(__hdr__) \ + ((struct ext4_extent *) (((char *) (__hdr__)) + \ + sizeof(struct ext4_extent_header))) +#define EXT_FIRST_INDEX(__hdr__) \ + ((struct ext4_extent_idx *) (((char *) (__hdr__)) + \ + sizeof(struct ext4_extent_header))) +#define EXT_LAST_EXTENT(__hdr__) \ + (EXT_FIRST_EXTENT((__hdr__)) + (__u16)((__hdr__)->eh_entries) - 1) +#define EXT_LAST_INDEX(__hdr__) \ + (EXT_FIRST_INDEX((__hdr__)) + (__u16)((__hdr__)->eh_entries) - 1) + + + /* linux/ext2fs.h */ /* * EXT2_DIR_PAD defines the directory entries boundaries @@ -270,8 +368,17 @@ /* kind of from ext2/super.c */ #define EXT2_BLOCK_SIZE(s) (1 << EXT2_BLOCK_SIZE_BITS(s)) /* linux/ext2fs.h */ +/* bergwolf: sizeof(struct ext2_group_desc) is changed in ext4 + * in kernel code, ext2/3 uses sizeof(struct ext2_group_desc) to calculate + * number of desc per block, while ext4 uses superblock->s_desc_size in stead + * superblock->s_desc_size is not available in ext2/3 + * */ +#define EXT2_DESC_SIZE(s) \ + (EXT4_HAS_INCOMPAT_FEATURE(s,EXT4_FEATURE_INCOMPAT_64BIT)? \ + s->s_desc_size : EXT4_MIN_DESC_SIZE) #define EXT2_DESC_PER_BLOCK(s) \ - (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_group_desc)) + (EXT2_BLOCK_SIZE(s) / EXT2_DESC_SIZE(s)) + /* linux/stat.h */ #define S_IFMT 00170000 #define S_IFLNK 0120000 @@ -475,6 +582,123 @@ [logical_block & (EXT2_ADDR_PER_BLOCK (SUPERBLOCK) - 1)]); } +/* extent binary search index + * find closest index in the current level extent tree + * kind of from ext4_ext_binsearch_idx in ext4/extents.c + */ +static struct ext4_extent_idx* +ext4_ext_binsearch_idx(struct ext4_extent_header* eh, int logical_block) +{ + struct ext4_extent_idx *r, *l, *m; + l = EXT_FIRST_INDEX(eh) + 1; + r = EXT_LAST_INDEX(eh); + while (l <= r) + { + m = l + (r - l) / 2; + if (logical_block < m->ei_block) + r = m - 1; + else + l = m + 1; + } + return (struct ext4_extent_idx*)(l - 1); +} + +/* extent binary search + * find closest extent in the leaf level + * kind of from ext4_ext_binsearch in ext4/extents.c + */ +static struct ext4_extent* +ext4_ext_binsearch(struct ext4_extent_header* eh, int logical_block) +{ + struct ext4_extent *r, *l, *m; + l = EXT_FIRST_EXTENT(eh) + 1; + r = EXT_LAST_EXTENT(eh); + while (l <= r) + { + m = l + (r - l) / 2; + if (logical_block < m->ee_block) + r = m - 1; + else + l = m + 1; + } + return (struct ext4_extent*)(l - 1); +} + +/* Maps extents enabled logical block into physical block via an inode. + * EXT4_HUGE_FILE_FL should be checked before calling this. + */ +static int +ext4fs_block_map (int logical_block) +{ + struct ext4_extent_header *eh; + struct ext4_extent *ex, *extent; + struct ext4_extent_idx *ei, *index; + int depth; + int i; + +#ifdef E2DEBUG + unsigned char *i; + for (i = (unsigned char *) INODE; + i < ((unsigned char *) INODE + sizeof (struct ext2_inode)); + i++) + { + printf ("%c", "0123456789abcdef"[*i >> 4]); + printf ("%c", "0123456789abcdef"[*i % 16]); + if (!((i + 1 - (unsigned char *) INODE) % 16)) + { + printf ("\n"); + } + else + { + printf (" "); + } + } + printf ("logical block %d\n", logical_block); +#endif /* E2DEBUG */ + eh = (struct ext4_extent_header*)INODE->i_block; + if (eh->eh_magic != EXT4_EXT_MAGIC) + { + errnum = ERR_FSYS_CORRUPT; + return -1; + } + while((depth = eh->eh_depth) != 0) + { /* extent index */ + if (eh->eh_magic != EXT4_EXT_MAGIC) + { + errnum = ERR_FSYS_CORRUPT; + return -1; + } + ei = ext4_ext_binsearch_idx(eh, logical_block); + if (ei->ei_leaf_hi) + {/* 64bit physical block number not supported */ + errnum = ERR_FILELENGTH; + return -1; + } + if (!ext2_rdfsb(ei->ei_leaf_lo, DATABLOCK1)) + { + errnum = ERR_FSYS_CORRUPT; + return -1; + } + printf("next level\n"); + eh = (struct ext4_extent_header*)DATABLOCK1; + } + + /* depth==0, we come to the leaf */ + ex = ext4_ext_binsearch(eh, logical_block); + if (ex->ee_start_hi) + {/* 64bit physical block number not supported */ + errnum = ERR_FILELENGTH; + return -1; + } + if ((ex->ee_block + ex->ee_len) < logical_block) + { + errnum = ERR_FSYS_CORRUPT; + return -1; + } + return ex->ee_start_lo + logical_block - ex->ee_block; + +} + /* preconditions: all preconds of ext2fs_block_map */ int ext2fs_read (char *buf, int len) @@ -495,7 +719,12 @@ /* find the (logical) block component of our location */ logical_block = filepos >> EXT2_BLOCK_SIZE_BITS (SUPERBLOCK); offset = filepos & (EXT2_BLOCK_SIZE (SUPERBLOCK) - 1); - map = ext2fs_block_map (logical_block); + /* map logical block of an extents enabled file into a physical block on the disk */ + if (EXT4_HAS_INCOMPAT_FEATURE(SUPERBLOCK,EXT4_FEATURE_INCOMPAT_EXTENTS) + && INODE->i_flags & EXT4_EXTENTS_FL) + map = ext4fs_block_map (logical_block); + else + map = ext2fs_block_map (logical_block); #ifdef E2DEBUG printf ("map=%d\n", map); #endif /* E2DEBUG */ @@ -579,7 +808,7 @@ int desc; /* index within that group */ int ino_blk; /* fs pointer of the inode's information */ int str_chk = 0; /* used to hold the results of a string compare */ - struct ext2_group_desc *gdp; + struct ext4_group_desc *ext4_gdp; struct ext2_inode *raw_inode; /* inode info corresponding to current_ino */ char linkbuf[PATH_MAX]; /* buffer for following symbolic links */ @@ -632,8 +861,15 @@ dump_group_desc(GROUP_DESC); #endif /* E2DEBUG */ - gdp = GROUP_DESC; - ino_blk = le32_to_cpu(gdp[desc].bg_inode_table) + + ext4_gdp = (struct ext4_group_desc *)( (__u8*)GROUP_DESC + + desc * EXT2_DESC_SIZE(SUPERBLOCK)); + if (EXT4_HAS_INCOMPAT_FEATURE(SUPERBLOCK, EXT4_FEATURE_INCOMPAT_64BIT) + && (! ext4_gdp->bg_inode_table_hi)) + {/* 64bit itable not supported */ + errnum = ERR_FILELENGTH; + return -1; + } + ino_blk = ext4_gdp->bg_inode_table + (((current_ino - 1) % le32_to_cpu(SUPERBLOCK->s_inodes_per_group)) >> log2 (EXT2_INODES_PER_BLOCK (SUPERBLOCK))); #ifdef E2DEBUG @@ -704,7 +940,10 @@ } linkbuf[filemax + len] = '\0'; - /* Read the symlink data. */ + /* Read the symlink data. + * Slow symlink is extents enabled + * But since grub_read invokes ext2fs_read, nothing to change here + * */ if (! ext2_is_fast_symlink ()) { /* Read the necessary blocks, and reset the file pointer. */ @@ -715,7 +954,9 @@ } else { - /* Copy the data directly from the inode. */ + /* Copy the data directly from the inode. + * Fast symlink is not extents enabled + * */ len = filemax; memmove (linkbuf, (char *) INODE->i_block, len); } @@ -749,6 +990,13 @@ errnum = ERR_BAD_FILETYPE; return 0; } + /* if file is too large, just stop and report an error*/ + if ( (INODE->i_flags & EXT4_HUGE_FILE_FL) && !(INODE->i_size_high)) + { + /* file too large, stop reading */ + errnum = ERR_FILELENGTH; + return 0; + } filemax = le32_to_cpu(INODE->i_size); return 1; @@ -803,17 +1051,28 @@ } /* else, find the (logical) block component of our location */ + /* ext4 logical block number the same as ext2/3 */ blk = loc >> EXT2_BLOCK_SIZE_BITS (SUPERBLOCK); /* we know which logical block of the directory entry we are looking for, now we have to translate that to the physical (fs) block on the disk */ - map = ext2fs_block_map (blk); + /* map logical block of an extents enabled file into a physical block on the disk */ + if (EXT4_HAS_INCOMPAT_FEATURE(SUPERBLOCK,EXT4_FEATURE_INCOMPAT_EXTENTS) + && INODE->i_flags & EXT4_EXTENTS_FL) + map = ext4fs_block_map (blk); + else + map = ext2fs_block_map (blk); #ifdef E2DEBUG printf ("ext2fs_dir: fs block=%d\n", map); #endif /* E2DEBUG */ mapblock2 = -1; - if ((map < 0) || !ext2_rdfsb (map, DATABLOCK2)) + if (map < 0) + { + *rest = ch; + return 0; + } + if (!ext2_rdfsb (map, DATABLOCK2)) { errnum = ERR_FSYS_CORRUPT; *rest = ch; -- coreboot mailing list: [email protected] http://www.coreboot.org/mailman/listinfo/coreboot
