Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/grub/patches/grub-0.97-ext4.patch

    Annotation of /trunk/grub/patches/grub-0.97-ext4.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 897 - (hide annotations) (download)
    Fri Oct 16 15:39:40 2009 UTC (14 years, 7 months ago) by niro
    File size: 16470 byte(s) 
    -fedora patches
    1 niro 897 Index: grub-0.97/stage2/fsys_ext2fs.c
    2     ===================================================================
    3     --- grub-0.97.orig/stage2/fsys_ext2fs.c
    4     +++ grub-0.97/stage2/fsys_ext2fs.c
    5     @@ -41,6 +41,7 @@ typedef __signed__ short __s16;
    6     typedef unsigned short __u16;
    7     typedef __signed__ int __s32;
    8     typedef unsigned int __u32;
    9     +typedef unsigned long long __u64;
    10    
    11     /*
    12     * Constants relative to the data blocks, from ext2_fs.h
    13     @@ -51,7 +52,7 @@ typedef unsigned int __u32;
    14     #define EXT2_TIND_BLOCK (EXT2_DIND_BLOCK + 1)
    15     #define EXT2_N_BLOCKS (EXT2_TIND_BLOCK + 1)
    16    
    17     -/* include/linux/ext2_fs.h */
    18     +/* lib/ext2fs/ext2_fs.h from e2fsprogs */
    19     struct ext2_super_block
    20     {
    21     __u32 s_inodes_count; /* Inodes count */
    22     @@ -61,9 +62,9 @@ struct ext2_super_block
    23     __u32 s_free_inodes_count; /* Free inodes count */
    24     __u32 s_first_data_block; /* First Data Block */
    25     __u32 s_log_block_size; /* Block size */
    26     - __s32 s_log_frag_size; /* Fragment size */
    27     + __s32 s_obso_log_frag_size; /* Obsoleted Fragment size */
    28     __u32 s_blocks_per_group; /* # Blocks per group */
    29     - __u32 s_frags_per_group; /* # Fragments per group */
    30     + __u32 s_obso_frags_per_group; /* Obsoleted Fragments per group */
    31     __u32 s_inodes_per_group; /* # Inodes per group */
    32     __u32 s_mtime; /* Mount time */
    33     __u32 s_wtime; /* Write time */
    34     @@ -72,7 +73,7 @@ struct ext2_super_block
    35     __u16 s_magic; /* Magic signature */
    36     __u16 s_state; /* File system state */
    37     __u16 s_errors; /* Behaviour when detecting errors */
    38     - __u16 s_pad;
    39     + __u16 s_minor_rev_level; /* minor revision level */
    40     __u32 s_lastcheck; /* time of last check */
    41     __u32 s_checkinterval; /* max. time between checks */
    42     __u32 s_creator_os; /* OS */
    43     @@ -119,15 +120,29 @@ struct ext2_super_block
    44     __u32 s_hash_seed[4]; /* HTREE hash seed */
    45     __u8 s_def_hash_version; /* Default hash version to use */
    46     __u8 s_jnl_backup_type; /* Default type of journal backup */
    47     - __u16 s_reserved_word_pad;
    48     + __u16 s_desc_size; /* size of group descriptor */
    49     __u32 s_default_mount_opts;
    50     __u32 s_first_meta_bg; /* First metablock group */
    51     __u32 s_mkfs_time; /* When the filesystem was created */
    52     __u32 s_jnl_blocks[17]; /* Backup of the journal inode */
    53     - __u32 s_reserved[172]; /* Padding to the end of the block */
    54     - };
    55     + /* 64bit desc support valid if EXT4_FEATURE_INCOMPAT_64BIT */
    56     + __u32 s_blocks_count_hi; /* Blocks count */
    57     + __u32 s_r_blocks_count_hi; /* Reserved blocks count */
    58     + __u32 s_free_blocks_count_hi; /* Free blocks count */
    59     + __u16 s_min_extra_isize; /* All inodes have at least # bytes */
    60     + __u16 s_max_extra_isize; /* New inodes should reverve # bytes */
    61     + __u32 s_flags; /* Miscellaneous flags */
    62     + __u16 s_raid_stride; /* Raid stride */
    63     + __u16 s_mmp_interval; /* # seconds to wait MMP checking */
    64     + __u64 s_mmp_block; /* Block for multi-mount protection */
    65     + __u32 s_raid_stripe_width; /* Blocks on all data disks (N*stride)*/
    66     + __u8 s_log_groups_per_flex;/* FLEX_BG group size*/
    67     + __u8 s_reserved_char_pad;
    68     + __u16 s_reserved_pad;
    69     + __u32 s_reserved[162]; /* Padding to the end of the block */
    70     +};
    71    
    72     -struct ext2_group_desc
    73     +struct ext4_group_desc
    74     {
    75     __u32 bg_block_bitmap; /* Blocks bitmap block */
    76     __u32 bg_inode_bitmap; /* Inodes bitmap block */
    77     @@ -135,8 +150,18 @@ struct ext2_group_desc
    78     __u16 bg_free_blocks_count; /* Free blocks count */
    79     __u16 bg_free_inodes_count; /* Free inodes count */
    80     __u16 bg_used_dirs_count; /* Directories count */
    81     - __u16 bg_pad;
    82     - __u32 bg_reserved[3];
    83     + __u16 bg_flags; /* EXT4_BG_flags (INODE_UNINIT, etc) */
    84     + __u32 bg_reserved[2]; /* Likely block/inode bitmap checksum */
    85     + __u16 bg_itable_unused; /* Unused inodes count */
    86     + __u16 bg_checksum; /* crc16(sb_uuid+group+desc) */
    87     + __u32 bg_block_bitmap_hi; /* Blocks bitmap block MSB */
    88     + __u32 bg_inode_bitmap_hi; /* Inodes bitmap block MSB */
    89     + __u32 bg_inode_table_hi; /* Inodes table block MSB */
    90     + __u16 bg_free_blocks_count_hi;/* Free blocks count MSB */
    91     + __u16 bg_free_inodes_count_hi;/* Free inodes count MSB */
    92     + __u16 bg_used_dirs_count_hi; /* Directories count MSB */
    93     + __u16 bg_itable_unused_hi; /* Unused inodes count MSB */
    94     + __u32 bg_reserved2[3];
    95     };
    96    
    97     struct ext2_inode
    98     @@ -174,22 +199,22 @@ struct ext2_inode
    99     __u32 i_block[EXT2_N_BLOCKS]; /* 40: Pointers to blocks */
    100     __u32 i_version; /* File version (for NFS) */
    101     __u32 i_file_acl; /* File ACL */
    102     - __u32 i_dir_acl; /* Directory ACL */
    103     - __u32 i_faddr; /* Fragment address */
    104     + __u32 i_size_high;
    105     + __u32 i_obso_faddr; /* Obsoleted fragment address */
    106     union
    107     {
    108     struct
    109     {
    110     - __u8 l_i_frag; /* Fragment number */
    111     - __u8 l_i_fsize; /* Fragment size */
    112     - __u16 i_pad1;
    113     - __u32 l_i_reserved2[2];
    114     + __u16 l_i_blocks_high; /* were l_i_reserved1 */
    115     + __u16 l_i_file_acl_high;
    116     + __u16 l_i_uid_high; /* these 2 fields */
    117     + __u16 l_i_gid_high; /* were reserved2[0] */
    118     + __u32 l_i_reserved2;
    119     }
    120     linux2;
    121     struct
    122     {
    123     - __u8 h_i_frag; /* Fragment number */
    124     - __u8 h_i_fsize; /* Fragment size */
    125     + __u16 h_i_reserved1; /* Obsoleted fragment number/size which are removed in ext4 */
    126     __u16 h_i_mode_high;
    127     __u16 h_i_uid_high;
    128     __u16 h_i_gid_high;
    129     @@ -198,16 +223,36 @@ struct ext2_inode
    130     hurd2;
    131     struct
    132     {
    133     - __u8 m_i_frag; /* Fragment number */
    134     - __u8 m_i_fsize; /* Fragment size */
    135     - __u16 m_pad1;
    136     + __u16 h_i_reserved1; /* Obsoleted fragment number/size which are removed in ext4 */
    137     + __u16 m_i_file_acl_high;
    138     __u32 m_i_reserved2[2];
    139     }
    140     masix2;
    141     }
    142     osd2; /* OS dependent 2 */
    143     + __u16 i_extra_isize;
    144     + __u16 i_pad1;
    145     + __u32 i_ctime_extra; /* extra Change time (nsec << 2 | epoch) */
    146     + __u32 i_mtime_extra; /* extra Modification time(nsec << 2 | epoch) */
    147     + __u32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */
    148     + __u32 i_crtime; /* File Creation time */
    149     + __u32 i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */
    150     + __u32 i_version_hi; /* high 32 bits for 64-bit version */
    151     };
    152    
    153     +#define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040 /* extents support */
    154     +#define EXT4_FEATURE_INCOMPAT_64BIT 0x0080 /* grub not supported*/
    155     +#define EXT4_FEATURE_INCOMPAT_MMP 0x0100
    156     +#define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200
    157     +
    158     +#define EXT4_HAS_INCOMPAT_FEATURE(sb,mask) \
    159     + ( sb->s_feature_incompat & mask )
    160     +
    161     +#define EXT4_EXTENTS_FL 0x00080000 /* Inode uses extents */
    162     +#define EXT4_HUGE_FILE_FL 0x00040000 /* Set to each huge file */
    163     +
    164     +#define EXT4_MIN_DESC_SIZE 32
    165     +
    166     /* linux/limits.h */
    167     #define NAME_MAX 255 /* # chars in a file name */
    168    
    169     @@ -225,6 +270,57 @@ struct ext2_dir_entry
    170     char name[EXT2_NAME_LEN]; /* File name */
    171     };
    172    
    173     +/* linux/ext4_fs_extents.h */
    174     +/* This is the extent on-disk structure.
    175     + * It's used at the bottom of the tree.
    176     + */
    177     +struct ext4_extent
    178     + {
    179     + __u32 ee_block; /* first logical block extent covers */
    180     + __u16 ee_len; /* number of blocks covered by extent */
    181     + __u16 ee_start_hi; /* high 16 bits of physical block */
    182     + __u32 ee_start_lo; /* low 32 bits of physical block */
    183     + };
    184     +
    185     +/*
    186     + * This is index on-disk structure.
    187     + * It's used at all the levels except the bottom.
    188     + */
    189     +struct ext4_extent_idx
    190     + {
    191     + __u32 ei_block; /* index covers logical blocks from 'block' */
    192     + __u32 ei_leaf_lo; /* pointer to the physical block of the next *
    193     + * level. leaf or next index could be there */
    194     + __u16 ei_leaf_hi; /* high 16 bits of physical block */
    195     + __u16 ei_unused;
    196     + };
    197     +
    198     +/*
    199     + * Each block (leaves and indexes), even inode-stored has header.
    200     + */
    201     +struct ext4_extent_header
    202     + {
    203     + __u16 eh_magic; /* probably will support different formats */
    204     + __u16 eh_entries; /* number of valid entries */
    205     + __u16 eh_max; /* capacity of store in entries */
    206     + __u16 eh_depth; /* has tree real underlying blocks? */
    207     + __u32 eh_generation; /* generation of the tree */
    208     + };
    209     +
    210     +#define EXT4_EXT_MAGIC (0xf30a)
    211     +#define EXT_FIRST_EXTENT(__hdr__) \
    212     + ((struct ext4_extent *) (((char *) (__hdr__)) + \
    213     + sizeof(struct ext4_extent_header)))
    214     +#define EXT_FIRST_INDEX(__hdr__) \
    215     + ((struct ext4_extent_idx *) (((char *) (__hdr__)) + \
    216     + sizeof(struct ext4_extent_header)))
    217     +#define EXT_LAST_EXTENT(__hdr__) \
    218     + (EXT_FIRST_EXTENT((__hdr__)) + (__u16)((__hdr__)->eh_entries) - 1)
    219     +#define EXT_LAST_INDEX(__hdr__) \
    220     + (EXT_FIRST_INDEX((__hdr__)) + (__u16)((__hdr__)->eh_entries) - 1)
    221     +
    222     +
    223     +
    224     /* linux/ext2fs.h */
    225     /*
    226     * EXT2_DIR_PAD defines the directory entries boundaries
    227     @@ -271,8 +367,17 @@ struct ext2_dir_entry
    228     /* kind of from ext2/super.c */
    229     #define EXT2_BLOCK_SIZE(s) (1 << EXT2_BLOCK_SIZE_BITS(s))
    230     /* linux/ext2fs.h */
    231     +/* sizeof(struct ext2_group_desc) is changed in ext4
    232     + * in kernel code, ext2/3 uses sizeof(struct ext2_group_desc) to calculate
    233     + * number of desc per block, while ext4 uses superblock->s_desc_size in stead
    234     + * superblock->s_desc_size is not available in ext2/3
    235     + * */
    236     +#define EXT2_DESC_SIZE(s) \
    237     + (EXT4_HAS_INCOMPAT_FEATURE(s,EXT4_FEATURE_INCOMPAT_64BIT)? \
    238     + s->s_desc_size : EXT4_MIN_DESC_SIZE)
    239     #define EXT2_DESC_PER_BLOCK(s) \
    240     - (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_group_desc))
    241     + (EXT2_BLOCK_SIZE(s) / EXT2_DESC_SIZE(s))
    242     +
    243     /* linux/stat.h */
    244     #define S_IFMT 00170000
    245     #define S_IFLNK 0120000
    246     @@ -434,6 +539,122 @@ ext2fs_block_map (int logical_block)
    247     [logical_block & (EXT2_ADDR_PER_BLOCK (SUPERBLOCK) - 1)];
    248     }
    249    
    250     +/* extent binary search index
    251     + * find closest index in the current level extent tree
    252     + * kind of from ext4_ext_binsearch_idx in ext4/extents.c
    253     + */
    254     +static struct ext4_extent_idx*
    255     +ext4_ext_binsearch_idx(struct ext4_extent_header* eh, int logical_block)
    256     +{
    257     + struct ext4_extent_idx *r, *l, *m;
    258     + l = EXT_FIRST_INDEX(eh) + 1;
    259     + r = EXT_LAST_INDEX(eh);
    260     + while (l <= r)
    261     + {
    262     + m = l + (r - l) / 2;
    263     + if (logical_block < m->ei_block)
    264     + r = m - 1;
    265     + else
    266     + l = m + 1;
    267     + }
    268     + return (struct ext4_extent_idx*)(l - 1);
    269     +}
    270     +
    271     +/* extent binary search
    272     + * find closest extent in the leaf level
    273     + * kind of from ext4_ext_binsearch in ext4/extents.c
    274     + */
    275     +static struct ext4_extent*
    276     +ext4_ext_binsearch(struct ext4_extent_header* eh, int logical_block)
    277     +{
    278     + struct ext4_extent *r, *l, *m;
    279     + l = EXT_FIRST_EXTENT(eh) + 1;
    280     + r = EXT_LAST_EXTENT(eh);
    281     + while (l <= r)
    282     + {
    283     + m = l + (r - l) / 2;
    284     + if (logical_block < m->ee_block)
    285     + r = m - 1;
    286     + else
    287     + l = m + 1;
    288     + }
    289     + return (struct ext4_extent*)(l - 1);
    290     +}
    291     +
    292     +/* Maps extents enabled logical block into physical block via an inode.
    293     + * EXT4_HUGE_FILE_FL should be checked before calling this.
    294     + */
    295     +static int
    296     +ext4fs_block_map (int logical_block)
    297     +{
    298     + struct ext4_extent_header *eh;
    299     + struct ext4_extent *ex, *extent;
    300     + struct ext4_extent_idx *ei, *index;
    301     + int depth;
    302     + int i;
    303     +
    304     +#ifdef E2DEBUG
    305     + unsigned char *i;
    306     + for (i = (unsigned char *) INODE;
    307     + i < ((unsigned char *) INODE + sizeof (struct ext2_inode));
    308     + i++)
    309     + {
    310     + printf ("%c", "0123456789abcdef"[*i >> 4]);
    311     + printf ("%c", "0123456789abcdef"[*i % 16]);
    312     + if (!((i + 1 - (unsigned char *) INODE) % 16))
    313     + {
    314     + printf ("\n");
    315     + }
    316     + else
    317     + {
    318     + printf (" ");
    319     + }
    320     + }
    321     + printf ("logical block %d\n", logical_block);
    322     +#endif /* E2DEBUG */
    323     + eh = (struct ext4_extent_header*)INODE->i_block;
    324     + if (eh->eh_magic != EXT4_EXT_MAGIC)
    325     + {
    326     + errnum = ERR_FSYS_CORRUPT;
    327     + return -1;
    328     + }
    329     + while((depth = eh->eh_depth) != 0)
    330     + { /* extent index */
    331     + if (eh->eh_magic != EXT4_EXT_MAGIC)
    332     + {
    333     + errnum = ERR_FSYS_CORRUPT;
    334     + return -1;
    335     + }
    336     + ei = ext4_ext_binsearch_idx(eh, logical_block);
    337     + if (ei->ei_leaf_hi)
    338     + {/* 64bit physical block number not supported */
    339     + errnum = ERR_FILELENGTH;
    340     + return -1;
    341     + }
    342     + if (!ext2_rdfsb(ei->ei_leaf_lo, DATABLOCK1))
    343     + {
    344     + errnum = ERR_FSYS_CORRUPT;
    345     + return -1;
    346     + }
    347     + eh = (struct ext4_extent_header*)DATABLOCK1;
    348     + }
    349     +
    350     + /* depth==0, we come to the leaf */
    351     + ex = ext4_ext_binsearch(eh, logical_block);
    352     + if (ex->ee_start_hi)
    353     + {/* 64bit physical block number not supported */
    354     + errnum = ERR_FILELENGTH;
    355     + return -1;
    356     + }
    357     + if ((ex->ee_block + ex->ee_len) < logical_block)
    358     + {
    359     + errnum = ERR_FSYS_CORRUPT;
    360     + return -1;
    361     + }
    362     + return ex->ee_start_lo + logical_block - ex->ee_block;
    363     +
    364     +}
    365     +
    366     /* preconditions: all preconds of ext2fs_block_map */
    367     int
    368     ext2fs_read (char *buf, int len)
    369     @@ -468,6 +689,11 @@ ext2fs_read (char *buf, int len)
    370     /* find the (logical) block component of our location */
    371     logical_block = filepos >> EXT2_BLOCK_SIZE_BITS (SUPERBLOCK);
    372     offset = filepos & (EXT2_BLOCK_SIZE (SUPERBLOCK) - 1);
    373     + /* map extents enabled logical block number to physical fs on-disk block number */
    374     + if (EXT4_HAS_INCOMPAT_FEATURE(SUPERBLOCK,EXT4_FEATURE_INCOMPAT_EXTENTS)
    375     + && INODE->i_flags & EXT4_EXTENTS_FL)
    376     + map = ext4fs_block_map (logical_block);
    377     + else
    378     map = ext2fs_block_map (logical_block);
    379     #ifdef E2DEBUG
    380     printf ("map=%d\n", map);
    381     @@ -552,7 +778,7 @@ ext2fs_dir (char *dirname)
    382     int desc; /* index within that group */
    383     int ino_blk; /* fs pointer of the inode's information */
    384     int str_chk = 0; /* used to hold the results of a string compare */
    385     - struct ext2_group_desc *gdp;
    386     + struct ext4_group_desc *ext4_gdp;
    387     struct ext2_inode *raw_inode; /* inode info corresponding to current_ino */
    388    
    389     char linkbuf[PATH_MAX]; /* buffer for following symbolic links */
    390     @@ -598,8 +824,15 @@ ext2fs_dir (char *dirname)
    391     {
    392     return 0;
    393     }
    394     - gdp = GROUP_DESC;
    395     - ino_blk = gdp[desc].bg_inode_table +
    396     + ext4_gdp = (struct ext4_group_desc *)( (__u8*)GROUP_DESC +
    397     + desc * EXT2_DESC_SIZE(SUPERBLOCK));
    398     + if (EXT4_HAS_INCOMPAT_FEATURE(SUPERBLOCK, EXT4_FEATURE_INCOMPAT_64BIT)
    399     + && (! ext4_gdp->bg_inode_table_hi))
    400     + {/* 64bit itable not supported */
    401     + errnum = ERR_FILELENGTH;
    402     + return -1;
    403     + }
    404     + ino_blk = ext4_gdp->bg_inode_table +
    405     (((current_ino - 1) % (SUPERBLOCK->s_inodes_per_group))
    406     >> log2 (EXT2_INODES_PER_BLOCK (SUPERBLOCK)));
    407     #ifdef E2DEBUG
    408     @@ -676,7 +909,10 @@ ext2fs_dir (char *dirname)
    409     }
    410     linkbuf[filemax + len] = '\0';
    411    
    412     - /* Read the symlink data. */
    413     + /* Read the symlink data.
    414     + * Slow symlink is extents enabled
    415     + * But since grub_read invokes ext2fs_read, nothing to change here
    416     + */
    417     if (! ext2_is_fast_symlink ())
    418     {
    419     /* Read the necessary blocks, and reset the file pointer. */
    420     @@ -687,7 +923,9 @@ ext2fs_dir (char *dirname)
    421     }
    422     else
    423     {
    424     - /* Copy the data directly from the inode. */
    425     + /* Copy the data directly from the inode.
    426     + * Fast symlink is not extents enabled
    427     + */
    428     len = filemax;
    429     memmove (linkbuf, (char *) INODE->i_block, len);
    430     }
    431     @@ -721,6 +959,13 @@ ext2fs_dir (char *dirname)
    432     errnum = ERR_BAD_FILETYPE;
    433     return 0;
    434     }
    435     + /* if file is too large, just stop and report an error*/
    436     + if ( (INODE->i_flags & EXT4_HUGE_FILE_FL) && !(INODE->i_size_high))
    437     + {
    438     + /* file too large, stop reading */
    439     + errnum = ERR_FILELENGTH;
    440     + return 0;
    441     + }
    442    
    443     filemax = (INODE->i_size);
    444     return 1;
    445     @@ -775,17 +1020,28 @@ ext2fs_dir (char *dirname)
    446     }
    447    
    448     /* else, find the (logical) block component of our location */
    449     + /* ext4 logical block number the same as ext2/3 */
    450     blk = loc >> EXT2_BLOCK_SIZE_BITS (SUPERBLOCK);
    451    
    452     /* we know which logical block of the directory entry we are looking
    453     for, now we have to translate that to the physical (fs) block on
    454     the disk */
    455     + /* map extents enabled logical block number to physical fs on-disk block number */
    456     + if (EXT4_HAS_INCOMPAT_FEATURE(SUPERBLOCK,EXT4_FEATURE_INCOMPAT_EXTENTS)
    457     + && INODE->i_flags & EXT4_EXTENTS_FL)
    458     + map = ext4fs_block_map (blk);
    459     + else
    460     map = ext2fs_block_map (blk);
    461     #ifdef E2DEBUG
    462     printf ("fs block=%d\n", map);
    463     #endif /* E2DEBUG */
    464     mapblock2 = -1;
    465     - if ((map < 0) || !ext2_rdfsb (map, DATABLOCK2))
    466     + if (map < 0)
    467     + {
    468     + *rest = ch;
    469     + return 0;
    470     + }
    471     + if (!ext2_rdfsb (map, DATABLOCK2))
    472     {
    473     errnum = ERR_FSYS_CORRUPT;
    474     *rest = ch;