grub-ext4-support.patch

   1 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;